Skip to content

Commit

Permalink
chromecast: Replace base::MakeUnique with std::make_unique
Browse files Browse the repository at this point in the history 
Should use std::make_unique directly instead of using base::MakeUnique
since August[1]. So, this change removes usages of base::MakeUnique in
//chromecast.

This change removes `#include "base/memory/ptr_util.h"` if it's no more
used in files. (Might not remove if base::WrapUnique is used)

This change also adds `#include <memory>` header except the following
two cases:
  - Not add the header if the file contains the <memory> header
  - Not add the header if the related header contains <memory> header
    (The style guide[2] says that foo.cc can rely on foo.h's includes)

Confirmed no additional lint errors(by `git cl lint`) after this change.

[1] https://chromium-review.googlesource.com/c/chromium/src/+/616016
[2] https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes

Bug: 755727
Change-Id: I64d44049e6778913ae7d6b4d83862d2ded4b105d
Reviewed-on: https://chromium-review.googlesource.com/874031
Reviewed-by: Sergey Volk <servolk@chromium.org>
Commit-Queue: Jinho Bang <jinho.bang@samsung.com>
Cr-Commit-Position: refs/heads/master@{#530323}
  • Loading branch information
@romandev
romandev authored and Commit Bot committed Jan 18, 2018
1 parent ebdc042 commit b10ad1f
Show file tree
Hide file tree
Showing 54 changed files with 197 additions and 214 deletions.
7 changes: 3 additions & 4 deletions chromecast/base/alarm_manager.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,6 @@

#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/clock.h"
Expand Down Expand Up @@ -67,15 +66,15 @@ AlarmManager::AlarmManager(
}

AlarmManager::AlarmManager()
: AlarmManager(base::MakeUnique<base::DefaultClock>(),
: AlarmManager(std::make_unique<base::DefaultClock>(),
base::ThreadTaskRunnerHandle::Get()) {}

AlarmManager::~AlarmManager() {}

std::unique_ptr<AlarmHandle> AlarmManager::PostAlarmTask(base::OnceClosure task,
base::Time time) {
DCHECK(task);
std::unique_ptr<AlarmHandle> handle = base::MakeUnique<AlarmHandle>();
std::unique_ptr<AlarmHandle> handle = std::make_unique<AlarmHandle>();
AddAlarm(base::BindOnce(&VerifyHandleCallback, std::move(task),
handle->AsWeakPtr()),
time, base::ThreadTaskRunnerHandle::Get());
Expand All @@ -87,7 +86,7 @@ void AlarmManager::AddAlarm(
base::Time time,
scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
MAKE_SURE_OWN_THREAD(AddAlarm, std::move(task), time, std::move(task_runner));
next_alarm_.push(base::MakeUnique<AlarmInfo>(std::move(task), time,
next_alarm_.push(std::make_unique<AlarmInfo>(std::move(task), time,
std::move(task_runner)));
}

Expand Down
61 changes: 30 additions & 31 deletions chromecast/base/alarm_manager_unittest.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,6 @@
#include <utility>

#include "base/bind.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/test/simple_test_clock.h"
#include "base/test/test_mock_time_task_runner.h"
Expand Down Expand Up @@ -51,11 +50,11 @@ TEST_F(AlarmManagerTest, AlarmNotFire) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

base::Time alarm_time = now + base::TimeDelta::FromMinutes(10);
std::unique_ptr<AlarmHandle> handle(manager->PostAlarmTask(
Expand All @@ -74,11 +73,11 @@ TEST_F(AlarmManagerTest, AlarmFire) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add an alarm.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(10);
Expand All @@ -105,10 +104,10 @@ TEST_F(AlarmManagerTest, AlarmPast) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add an alarm in the past. Should fire right away.
base::Time alarm_time = base::Time::Now() - base::TimeDelta::FromMinutes(10);
Expand All @@ -127,11 +126,11 @@ TEST_F(AlarmManagerTest, AlarmTimeJump) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add an alarm. The time jumps to the future.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(10);
Expand All @@ -151,11 +150,11 @@ TEST_F(AlarmManagerTest, AlarmJumpFuture) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add an alarm. The time jumps far into the future.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(10);
Expand All @@ -177,11 +176,11 @@ TEST_F(AlarmManagerTest, AlarmMultiple) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(10);
Expand Down Expand Up @@ -223,11 +222,11 @@ TEST_F(AlarmManagerTest, AlarmMultipleReverseOrder) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(12);
Expand Down Expand Up @@ -271,11 +270,11 @@ TEST_F(AlarmManagerTest, AlarmMultipleSameTime) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(12);
Expand Down Expand Up @@ -315,11 +314,11 @@ TEST_F(AlarmManagerTest, AlarmMultipleShuffle) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(15);
Expand Down Expand Up @@ -364,11 +363,11 @@ TEST_F(AlarmManagerTest, AlarmTwice) {
// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(15);
Expand Down Expand Up @@ -408,23 +407,23 @@ TEST_F(AlarmManagerTest, AlarmTwice) {

TEST_F(AlarmManagerTest, AlarmCancel) {
std::unique_ptr<WallClockDependantTask> task1 =
base::MakeUnique<WallClockDependantTask>();
std::make_unique<WallClockDependantTask>();
std::unique_ptr<WallClockDependantTask> task2 =
base::MakeUnique<WallClockDependantTask>();
std::make_unique<WallClockDependantTask>();
std::unique_ptr<WallClockDependantTask> task3 =
base::MakeUnique<WallClockDependantTask>();
std::make_unique<WallClockDependantTask>();
ASSERT_FALSE(task1->fired_);
ASSERT_FALSE(task2->fired_);
ASSERT_FALSE(task3->fired_);

// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(12);
Expand Down Expand Up @@ -457,23 +456,23 @@ TEST_F(AlarmManagerTest, AlarmCancel) {

TEST_F(AlarmManagerTest, AlarmDeleteHandle) {
std::unique_ptr<WallClockDependantTask> task1 =
base::MakeUnique<WallClockDependantTask>();
std::make_unique<WallClockDependantTask>();
std::unique_ptr<WallClockDependantTask> task2 =
base::MakeUnique<WallClockDependantTask>();
std::make_unique<WallClockDependantTask>();
std::unique_ptr<WallClockDependantTask> task3 =
base::MakeUnique<WallClockDependantTask>();
std::make_unique<WallClockDependantTask>();
ASSERT_FALSE(task1->fired_);
ASSERT_FALSE(task2->fired_);
ASSERT_FALSE(task3->fired_);

// Create the AlarmManager.
base::Time now = base::Time::Now();
std::unique_ptr<base::SimpleTestClock> test_clock =
base::MakeUnique<base::SimpleTestClock>();
std::make_unique<base::SimpleTestClock>();
test_clock->SetNow(now);
base::SimpleTestClock* clock = test_clock.get();
std::unique_ptr<AlarmManager> manager =
base::MakeUnique<AlarmManager>(std::move(test_clock), task_runner_);
std::make_unique<AlarmManager>(std::move(test_clock), task_runner_);

// Add first task.
base::Time alarm_time = now + base::TimeDelta::FromMinutes(12);
Expand Down
9 changes: 4 additions & 5 deletions chromecast/base/bind_to_task_runner_unittest.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,6 @@
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "testing/gmock/include/gmock/gmock.h"
Expand Down Expand Up @@ -94,7 +93,7 @@ TEST_F(BindToTaskRunnerTest, OnceCallbackWithUnboundConstRef) {
TEST_F(BindToTaskRunnerTest, OnceCallbackWithBoundMoveOnly) {
base::OnceCallback<void()> callback = BindToCurrentThread(base::BindOnce(
&Callbacks::MoveOnlyCallback, base::Unretained(&callbacks_),
base::MakeUnique<Type>(kValue)));
std::make_unique<Type>(kValue)));
std::move(callback).Run();
EXPECT_CALL(callbacks_, DoMoveOnlyCallback(Pointee(kValue)));
}
Expand All @@ -103,7 +102,7 @@ TEST_F(BindToTaskRunnerTest, OnceCallbackWithUnboundMoveOnly) {
base::OnceCallback<void(std::unique_ptr<Type>)> callback =
BindToCurrentThread(base::BindOnce(&Callbacks::MoveOnlyCallback,
base::Unretained(&callbacks_)));
std::move(callback).Run(base::MakeUnique<Type>(kValue));
std::move(callback).Run(std::make_unique<Type>(kValue));
EXPECT_CALL(callbacks_, DoMoveOnlyCallback(Pointee(kValue)));
}

Expand Down Expand Up @@ -150,7 +149,7 @@ TEST_F(BindToTaskRunnerTest, RepeatingCallbackWithBoundMoveOnly) {
base::RepeatingCallback<void()> callback =
BindToCurrentThread(base::BindRepeating(
&Callbacks::MoveOnlyCallback, base::Unretained(&callbacks_),
base::Passed(base::MakeUnique<Type>(kValue))));
base::Passed(std::make_unique<Type>(kValue))));
callback.Run();
EXPECT_CALL(callbacks_, DoMoveOnlyCallback(Pointee(kValue)));
}
Expand All @@ -159,7 +158,7 @@ TEST_F(BindToTaskRunnerTest, RepeatingCallbackWithUnboundMoveOnly) {
base::RepeatingCallback<void(std::unique_ptr<Type>)> callback =
BindToCurrentThread(base::BindRepeating(&Callbacks::MoveOnlyCallback,
base::Unretained(&callbacks_)));
callback.Run(base::MakeUnique<Type>(kValue));
callback.Run(std::make_unique<Type>(kValue));
EXPECT_CALL(callbacks_, DoMoveOnlyCallback(Pointee(kValue)));
}

Expand Down
8 changes: 4 additions & 4 deletions chromecast/base/cast_features.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -78,8 +78,8 @@ void SetExperimentIds(const base::ListValue& list) {
//
// std::unique_ptr<Foo> CreateFoo() {
// if (base::FeatureList::IsEnabled(kSuperSecretSauce))
// return base::MakeUnique<SuperSecretFoo>();
// return base::MakeUnique<BoringOldFoo>();
// return std::make_unique<SuperSecretFoo>();
// return std::make_unique<BoringOldFoo>();
// }
//
// base::FeatureList can be called from any thread, in any process, at any
Expand Down Expand Up @@ -140,7 +140,7 @@ void InitializeFeatureList(const base::DictionaryValue& dcs_features,
SetExperimentIds(dcs_experiment_ids);

// Initialize the FeatureList from the command line.
auto feature_list = base::MakeUnique<base::FeatureList>();
auto feature_list = std::make_unique<base::FeatureList>();
feature_list->InitializeFromCommandLine(cmd_line_enable_features,
cmd_line_disable_features);

Expand Down Expand Up @@ -234,7 +234,7 @@ base::DictionaryValue GetOverriddenFeaturesForStorage(

const base::DictionaryValue* params_dict;
if (it.value().GetAsDictionary(&params_dict)) {
auto params = base::MakeUnique<base::DictionaryValue>();
auto params = std::make_unique<base::DictionaryValue>();

bool bval;
int ival;
Expand Down
Loading

0 comments on commit b10ad1f

Please sign in to comment.