Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/activity_log/counting_policy_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/activity_log/counting_policy.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/simple_test_clock.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/activity_log/activity_log.h"
@@ skipping 50 matching lines @@
   // Wait for the task queue for the specified thread to empty.
   void WaitOnThread(const BrowserThread::ID& thread) {
     BrowserThread::PostTaskAndReply(
         thread, FROM_HERE, base::Bind(&base::DoNothing),
         base::MessageLoop::current()->QuitWhenIdleClosure());
     base::MessageLoop::current()->Run();
   }
 
   // A wrapper function for CheckReadFilteredData, so that we don't need to
   // enter empty string values for parameters we don't care about.
-  void CheckReadData(
-      ActivityLogDatabasePolicy* policy,
-      const std::string& extension_id,
-      int day,
-      const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) {
+  void CheckReadData(ActivityLogDatabasePolicy* policy,
+                     const std::string& extension_id,
+                     int day,
+                     const base::Callback<void(
+                         std::unique_ptr<Action::ActionVector>)>& checker) {
     CheckReadFilteredData(
         policy, extension_id, Action::ACTION_ANY, "", "", "", day, checker);
   }
 
   // A helper function to call ReadFilteredData on a policy object and wait for
   // the results to be processed.
   void CheckReadFilteredData(
       ActivityLogDatabasePolicy* policy,
       const std::string& extension_id,
       const Action::ActionType type,
       const std::string& api_name,
       const std::string& page_url,
       const std::string& arg_url,
       int day,
-      const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) {
+      const base::Callback<void(std::unique_ptr<Action::ActionVector>)>&
+          checker) {
     // Submit a request to the policy to read back some data, and call the
     // checker function when results are available.  This will happen on the
     // database thread.
     policy->ReadFilteredData(
         extension_id, type, api_name, page_url, arg_url, day,
         base::Bind(&CountingPolicyTest::CheckWrapper, checker,
                    base::MessageLoop::current()->QuitWhenIdleClosure()));
 
     // Set up a timeout for receiving results; if we haven't received anything
     // when the timeout triggers then assume that the test is broken.
@@ skipping 27 matching lines @@
   }
 
   // Checks that the number of queued actions to be written out does not exceed
   // kSizeThresholdForFlush.  Runs on the database thread.
   static void CheckQueueSize(CountingPolicy* policy) {
     // This should be updated if kSizeThresholdForFlush in activity_database.cc
     // changes.
     ASSERT_LE(policy->queued_actions_.size(), 200U);
   }
 
-  static void CheckWrapper(
-      const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker,
-      const base::Closure& done,
-      scoped_ptr<Action::ActionVector> results) {
+  static void CheckWrapper(const base::Callback<void(
+                               std::unique_ptr<Action::ActionVector>)>& checker,
+                           const base::Closure& done,
+                           std::unique_ptr<Action::ActionVector> results) {
     checker.Run(std::move(results));
     done.Run();
   }
 
   static void TimeoutCallback() {
     base::MessageLoop::current()->QuitWhenIdle();
     FAIL() << "Policy test timed out waiting for results";
   }
 
   static void RetrieveActions_FetchFilteredActions0(
-      scoped_ptr<std::vector<scoped_refptr<Action> > > i) {
+      std::unique_ptr<std::vector<scoped_refptr<Action>>> i) {
     ASSERT_EQ(0, static_cast<int>(i->size()));
   }
 
   static void RetrieveActions_FetchFilteredActions1(
-      scoped_ptr<std::vector<scoped_refptr<Action> > > i) {
+      std::unique_ptr<std::vector<scoped_refptr<Action>>> i) {
     ASSERT_EQ(1, static_cast<int>(i->size()));
   }
 
   static void RetrieveActions_FetchFilteredActions2(
-      scoped_ptr<std::vector<scoped_refptr<Action> > > i) {
+      std::unique_ptr<std::vector<scoped_refptr<Action>>> i) {
     ASSERT_EQ(2, static_cast<int>(i->size()));
   }
 
   static void RetrieveActions_FetchFilteredActions300(
-      scoped_ptr<std::vector<scoped_refptr<Action> > > i) {
+      std::unique_ptr<std::vector<scoped_refptr<Action>>> i) {
     ASSERT_EQ(300, static_cast<int>(i->size()));
   }
 
-  static void Arguments_Stripped(scoped_ptr<Action::ActionVector> i) {
+  static void Arguments_Stripped(std::unique_ptr<Action::ActionVector> i) {
     scoped_refptr<Action> last = i->front();
     CheckAction(*last.get(),
                 "odlameecjipmbmbejkplpemijjgpljce",
                 Action::ACTION_API_CALL,
                 "extension.connect",
                 "[\"hello\",\"world\"]",
                 "",
                 "",
                 "",
                 1);
   }
 
   static void Arguments_GetSinglesAction(
-      scoped_ptr<Action::ActionVector> actions) {
+      std::unique_ptr<Action::ActionVector> actions) {
     ASSERT_EQ(1, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "",
                 "http://www.google.com/",
                 "",
                 "",
                 1);
   }
 
   static void Arguments_GetTodaysActions(
-      scoped_ptr<Action::ActionVector> actions) {
+      std::unique_ptr<Action::ActionVector> actions) {
     ASSERT_EQ(3, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky",
                 Action::ACTION_API_CALL,
                 "brewster",
                 "",
                 "",
                 "",
                 "",
                 2);
@@ skipping 11 matching lines @@
                 Action::ACTION_API_CALL,
                 "extension.sendMessage",
                 "[\"not\",\"stripped\"]",
                 "",
                 "",
                 "",
                 1);
   }
 
   static void Arguments_GetOlderActions(
-      scoped_ptr<Action::ActionVector> actions) {
+      std::unique_ptr<Action::ActionVector> actions) {
     ASSERT_EQ(2, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "",
                 "http://www.google.com/",
                 "",
                 "",
                 1);
     CheckAction(*actions->at(1).get(),
                 "punky",
                 Action::ACTION_API_CALL,
                 "brewster",
                 "",
                 "",
                 "",
                 "",
                 1);
   }
 
   static void Arguments_CheckMergeCount(
       int count,
-      scoped_ptr<Action::ActionVector> actions) {
+      std::unique_ptr<Action::ActionVector> actions) {
     if (count > 0) {
       ASSERT_EQ(1u, actions->size());
       CheckAction(*actions->at(0).get(),
                   "punky",
                   Action::ACTION_API_CALL,
                   "brewster",
                   "",
                   "",
                   "",
                   "",
                   count);
     } else {
       ASSERT_EQ(0u, actions->size());
     }
   }
 
   static void Arguments_CheckMergeCountAndTime(
       int count,
       const base::Time& time,
-      scoped_ptr<Action::ActionVector> actions) {
+      std::unique_ptr<Action::ActionVector> actions) {
     if (count > 0) {
       ASSERT_EQ(1u, actions->size());
       CheckAction(*actions->at(0).get(),
                   "punky",
                   Action::ACTION_API_CALL,
                   "brewster",
                   "",
                   "",
                   "",
                   "",
                   count);
       ASSERT_EQ(time, actions->at(0)->time());
     } else {
       ASSERT_EQ(0u, actions->size());
     }
   }
 
-  static void AllURLsRemoved(scoped_ptr<Action::ActionVector> actions) {
+  static void AllURLsRemoved(std::unique_ptr<Action::ActionVector> actions) {
     ASSERT_EQ(2, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "",
                 "",
                 "",
                 "",
                 1);
     CheckAction(*actions->at(1).get(),
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "",
                 "",
                 "",
                 "",
                 1);
   }
 
-  static void SomeURLsRemoved(scoped_ptr<Action::ActionVector> actions) {
+  static void SomeURLsRemoved(std::unique_ptr<Action::ActionVector> actions) {
     // These will be in the vector in reverse time order.
     ASSERT_EQ(5, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "",
                 "http://www.google.com/",
                 "Google",
                 "http://www.args-url.com/",
@@ skipping 29 matching lines @@
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "",
                 "",
                 "",
                 "",
                 1);
   }
 
-  static void CheckDuplicates(scoped_ptr<Action::ActionVector> actions) {
+  static void CheckDuplicates(std::unique_ptr<Action::ActionVector> actions) {
     ASSERT_EQ(2u, actions->size());
     int total_count = 0;
     for (size_t i = 0; i < actions->size(); i++) {
       total_count += actions->at(i)->count();
     }
     ASSERT_EQ(3, total_count);
   }
 
   static void CheckAction(const Action& action,
                           const std::string& expected_id,
@@ skipping 15 matching lines @@
     ASSERT_EQ(expected_count, action.count());
     ASSERT_NE(-1, action.action_id());
   }
 
   // A helper function initializes the policy with a number of actions, calls
   // RemoveActions on a policy object and then checks the result of the
   // deletion.
   void CheckRemoveActions(
       ActivityLogDatabasePolicy* policy,
       const std::vector<int64_t>& action_ids,
-      const base::Callback<void(scoped_ptr<Action::ActionVector>)>& checker) {
+      const base::Callback<void(std::unique_ptr<Action::ActionVector>)>&
+          checker) {
     // Use a mock clock to ensure that events are not recorded on the wrong day
     // when the test is run close to local midnight.
     base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
     mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                        base::TimeDelta::FromHours(12));
-    policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+    policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
     // Record some actions
     scoped_refptr<Action> action =
         new Action("punky1",
                    mock_clock->Now() - base::TimeDelta::FromMinutes(40),
                    Action::ACTION_DOM_ACCESS,
                    "lets1");
     action->mutable_args()->AppendString("vamoose1");
     action->set_page_url(GURL("http://www.google1.com"));
     action->set_page_title("Google1");
@@ skipping 20 matching lines @@
     policy->RemoveActions(action_ids);
 
     // Check the result of the deletion. The checker function gets all
     // activities in the database.
     CheckReadData(policy, "", -1, checker);
 
     // Clean database.
     policy->DeleteDatabase();
   }
 
-  static void AllActionsDeleted(scoped_ptr<Action::ActionVector> actions) {
+  static void AllActionsDeleted(std::unique_ptr<Action::ActionVector> actions) {
     ASSERT_EQ(0, static_cast<int>(actions->size()));
   }
 
-  static void NoActionsDeleted(scoped_ptr<Action::ActionVector> actions) {
+  static void NoActionsDeleted(std::unique_ptr<Action::ActionVector> actions) {
     // These will be in the vector in reverse time order.
     ASSERT_EQ(2, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky2",
                 Action::ACTION_API_CALL,
                 "lets2",
                 "",
                 "http://www.google2.com/",
                 "Google2",
                 "http://www.args-url2.com/",
                 2);
     ASSERT_EQ(2, actions->at(0)->action_id());
     CheckAction(*actions->at(1).get(),
                 "punky1",
                 Action::ACTION_DOM_ACCESS,
                 "lets1",
                 "",
                 "http://www.google1.com/",
                 "Google1",
                 "http://www.args-url1.com/",
                 2);
     ASSERT_EQ(1, actions->at(1)->action_id());
   }
 
-  static void Action1Deleted(scoped_ptr<Action::ActionVector> actions) {
+  static void Action1Deleted(std::unique_ptr<Action::ActionVector> actions) {
     // These will be in the vector in reverse time order.
     ASSERT_EQ(1, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky2",
                 Action::ACTION_API_CALL,
                 "lets2",
                 "",
                 "http://www.google2.com/",
                 "Google2",
                 "http://www.args-url2.com/",
                 2);
     ASSERT_EQ(2, actions->at(0)->action_id());
   }
 
-  static void Action2Deleted(scoped_ptr<Action::ActionVector> actions) {
+  static void Action2Deleted(std::unique_ptr<Action::ActionVector> actions) {
     // These will be in the vector in reverse time order.
     ASSERT_EQ(1, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky1",
                 Action::ACTION_DOM_ACCESS,
                 "lets1",
                 "",
                 "http://www.google1.com/",
                 "Google1",
                 "http://www.args-url1.com/",
                 2);
     ASSERT_EQ(1, actions->at(0)->action_id());
   }
 
  protected:
   ExtensionService* extension_service_;
-  scoped_ptr<TestingProfile> profile_;
+  std::unique_ptr<TestingProfile> profile_;
   content::TestBrowserThreadBundle thread_bundle_;
   // Used to preserve a copy of the original command line.
   // The test framework will do this itself as well. However, by then,
   // it is too late to call ActivityLog::RecomputeLoggingIsEnabled() in
   // TearDown().
   base::CommandLine saved_cmdline_;
 
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
-  scoped_ptr<chromeos::ScopedTestUserManager> test_user_manager_;
+  std::unique_ptr<chromeos::ScopedTestUserManager> test_user_manager_;
 #endif
 };
 
 TEST_F(CountingPolicyTest, Construct) {
   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
           .SetManifest(DictionaryBuilder()
                            .Set("name", "Test extension")
                            .Set("version", "1.0.0")
                            .Set("manifest_version", 2)
                            .Build())
           .Build();
   extension_service_->AddExtension(extension.get());
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   scoped_refptr<Action> action = new Action(extension->id(),
                                             base::Time::Now(),
                                             Action::ACTION_API_CALL,
                                             "tabs.testMethod");
   action->set_args(std::move(args));
   policy->ProcessAction(action);
   policy->Close();
 }
 
 TEST_F(CountingPolicyTest, LogWithStrippedArguments) {
   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
   scoped_refptr<const Extension> extension =
       ExtensionBuilder()
           .SetManifest(DictionaryBuilder()
                            .Set("name", "Test extension")
                            .Set("version", "1.0.0")
                            .Set("manifest_version", 2)
                            .Build())
           .Build();
   extension_service_->AddExtension(extension.get());
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Set(0, new base::StringValue("hello"));
   args->Set(1, new base::StringValue("world"));
   scoped_refptr<Action> action = new Action(extension->id(),
                                             base::Time::Now(),
                                             Action::ACTION_API_CALL,
                                             "extension.connect");
   action->set_args(std::move(args));
 
   policy->ProcessAction(action);
   CheckReadData(policy,
@@ skipping 11 matching lines @@
   policy->set_retention_time(base::TimeDelta::FromDays(14));
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.  Note: Ownership is passed
   // to the policy, but we still keep a pointer locally.  The policy will take
   // care of destruction; this is safe since the policy outlives all our
   // accesses to the mock clock.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record some actions
   scoped_refptr<Action> action =
       new Action("punky",
                  mock_clock->Now() - base::TimeDelta::FromMinutes(40),
                  Action::ACTION_API_CALL,
                  "brewster");
   action->mutable_args()->AppendString("woof");
   policy->ProcessAction(action);
 
@@ skipping 36 matching lines @@
 TEST_F(CountingPolicyTest, GetOlderActions) {
   CountingPolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
   policy->set_retention_time(base::TimeDelta::FromDays(14));
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record some actions
   scoped_refptr<Action> action =
       new Action("punky",
                  mock_clock->Now() - base::TimeDelta::FromDays(3) -
                      base::TimeDelta::FromMinutes(40),
                  Action::ACTION_API_CALL,
                  "brewster");
   action->mutable_args()->AppendString("woof");
   policy->ProcessAction(action);
@@ skipping 43 matching lines @@
                            .Build())
           .Build();
   extension_service_->AddExtension(extension.get());
   GURL gurl("http://www.google.com");
 
   // Write some API calls
   scoped_refptr<Action> action_api = new Action(extension->id(),
                                                 base::Time::Now(),
                                                 Action::ACTION_API_CALL,
                                                 "tabs.testMethod");
-  action_api->set_args(make_scoped_ptr(new base::ListValue()));
+  action_api->set_args(base::WrapUnique(new base::ListValue()));
   policy->ProcessAction(action_api);
 
   scoped_refptr<Action> action_dom = new Action(extension->id(),
                                                 base::Time::Now(),
                                                 Action::ACTION_DOM_ACCESS,
                                                 "document.write");
-  action_dom->set_args(make_scoped_ptr(new base::ListValue()));
+  action_dom->set_args(base::WrapUnique(new base::ListValue()));
   action_dom->set_page_url(gurl);
   policy->ProcessAction(action_dom);
 
   CheckReadFilteredData(
       policy,
       extension->id(),
       Action::ACTION_API_CALL,
       "tabs.testMethod",
       "",
       "",
@@ skipping 66 matching lines @@
   policy->Init();
   // Initially disable expiration by setting a retention time before any
   // actions we generate.
   policy->set_retention_time(base::TimeDelta::FromDays(14));
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                     base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // The first two actions should be merged; the last one is on a separate day
   // and should not be.
   scoped_refptr<Action> action =
       new Action("punky",
                  mock_clock->Now() - base::TimeDelta::FromDays(3) -
                      base::TimeDelta::FromMinutes(40),
                  Action::ACTION_API_CALL,
                  "brewster");
   policy->ProcessAction(action);
@@ skipping 46 matching lines @@
 // Test cleaning of old data in the string and URL tables.
 TEST_F(CountingPolicyTest, StringTableCleaning) {
   CountingPolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
   // Initially disable expiration by setting a retention time before any
   // actions we generate.
   policy->set_retention_time(base::TimeDelta::FromDays(14));
 
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now());
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Insert an action; this should create entries in both the string table (for
   // the extension and API name) and the URL table (for page_url).
   scoped_refptr<Action> action =
       new Action("punky",
                  mock_clock->Now() - base::TimeDelta::FromDays(7),
                  Action::ACTION_API_CALL,
                  "brewster");
   action->set_page_url(GURL("http://www.google.com/"));
   policy->ProcessAction(action);
@@ skipping 35 matching lines @@
 TEST_F(CountingPolicyTest, MoreMerging) {
   CountingPolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
   policy->set_retention_time(base::TimeDelta::FromDays(14));
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                     base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Create an action 2 days ago, then 1 day ago, then 2 days ago.  Make sure
   // that we end up with two merged records (one for each day), and each has
   // the appropriate timestamp.  These merges should happen in the database
   // since the date keeps changing.
   base::Time time1 =
       mock_clock->Now() - base::TimeDelta::FromDays(2) -
       base::TimeDelta::FromMinutes(40);
   base::Time time2 =
       mock_clock->Now() - base::TimeDelta::FromDays(1) -
@@ skipping 102 matching lines @@
 
 TEST_F(CountingPolicyTest, RemoveAllURLs) {
   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record some actions
   scoped_refptr<Action> action =
       new Action("punky", mock_clock->Now(),
                  Action::ACTION_DOM_ACCESS, "lets");
   action->mutable_args()->AppendString("vamoose");
   action->set_page_url(GURL("http://www.google.com"));
   action->set_page_title("Google");
   action->set_arg_url(GURL("http://www.args-url.com"));
   policy->ProcessAction(action);
@@ skipping 22 matching lines @@
 
 TEST_F(CountingPolicyTest, RemoveSpecificURLs) {
   ActivityLogDatabasePolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record some actions
   // This should have the page url and args url cleared.
   scoped_refptr<Action> action = new Action("punky", mock_clock->Now(),
                                             Action::ACTION_DOM_ACCESS, "lets");
   action->mutable_args()->AppendString("vamoose");
   action->set_page_url(GURL("http://www.google1.com"));
   action->set_page_title("Google");
   action->set_arg_url(GURL("http://www.google1.com"));
   policy->ProcessAction(action);
@@ skipping 56 matching lines @@
 
 TEST_F(CountingPolicyTest, RemoveExtensionData) {
   CountingPolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record some actions
   scoped_refptr<Action> action = new Action("deleteextensiondata",
                                             mock_clock->Now(),
                                             Action::ACTION_DOM_ACCESS,
                                             "lets");
   action->mutable_args()->AppendString("vamoose");
   action->set_page_title("Google");
   action->set_arg_url(GURL("http://www.google.com"));
   policy->ProcessAction(action);
@@ skipping 44 matching lines @@
   policy->set_retention_time(base::TimeDelta::FromDays(14));
 
   // Use a mock clock to ensure that events are not recorded on the wrong day
   // when the test is run close to local midnight.  Note: Ownership is passed
   // to the policy, but we still keep a pointer locally.  The policy will take
   // care of destruction; this is safe since the policy outlives all our
   // accesses to the mock clock.
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record some actions
   scoped_refptr<Action> action =
       new Action("punky",
                  mock_clock->Now() - base::TimeDelta::FromMinutes(40),
                  Action::ACTION_API_CALL,
                  "brewster");
   action->mutable_args()->AppendString("woof");
   policy->ProcessAction(action);
 
@@ skipping 75 matching lines @@
 }
 
 // Tests that duplicate rows in the activity log database are handled properly
 // when updating counts.
 TEST_F(CountingPolicyTest, DuplicateRows) {
   CountingPolicy* policy = new CountingPolicy(profile_.get());
   policy->Init();
   base::SimpleTestClock* mock_clock = new base::SimpleTestClock();
   mock_clock->SetNow(base::Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(12));
-  policy->SetClockForTesting(scoped_ptr<base::Clock>(mock_clock));
+  policy->SetClockForTesting(std::unique_ptr<base::Clock>(mock_clock));
 
   // Record two actions with distinct URLs.
   scoped_refptr<Action> action;
   action = new Action(
       "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster");
   action->set_page_url(GURL("http://www.google.com"));
   policy->ProcessAction(action);
 
   action = new Action(
       "punky", mock_clock->Now(), Action::ACTION_API_CALL, "brewster");
@@ skipping 59 matching lines @@
 
   action_ids.push_back(2);
   CheckRemoveActions(
       policy, action_ids, base::Bind(&CountingPolicyTest::Action2Deleted));
   action_ids.clear();
 
   policy->Close();
 }
 
 }  // namespace extensions