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

chrome/browser/extensions/activity_log/fullstream_ui_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/fullstream_ui_policy.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/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"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 42 matching lines @@
 #endif
     base::RunLoop().RunUntilIdle();
     profile_.reset(NULL);
     base::RunLoop().RunUntilIdle();
     // Restore the original command line and undo the affects of SetUp().
     *base::CommandLine::ForCurrentProcess() = saved_cmdline_;
   }
 
   // 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,
       const int days_ago,
-      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, days_ago,
         base::Bind(&FullStreamUIPolicyTest::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.
     base::CancelableClosure timeout(
         base::Bind(&FullStreamUIPolicyTest::TimeoutCallback));
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, timeout.callback(), TestTimeouts::action_timeout());
 
     // Wait for results; either the checker or the timeout callbacks should
     // cause the main loop to exit.
     base::MessageLoop::current()->Run();
 
     timeout.Cancel();
   }
 
-  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_LogAndFetchActions(
-      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_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_Present(scoped_ptr<Action::ActionVector> i) {
+  static void Arguments_Present(std::unique_ptr<Action::ActionVector> i) {
     scoped_refptr<Action> last = i->front();
     CheckAction(*last.get(),
                 "odlameecjipmbmbejkplpemijjgpljce",
                 Action::ACTION_API_CALL,
                 "extension.connect",
                 "[\"hello\",\"world\"]",
                 "",
                 "",
                 "");
   }
 
   static void Arguments_GetTodaysActions(
-      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",
                 "[\"vamoose\"]",
                 "http://www.google.com/",
                 "Page Title",
                 "http://www.arg-url.com/");
     CheckAction(*actions->at(1).get(),
                 "punky",
                 Action::ACTION_API_CALL,
                 "brewster",
                 "[\"woof\"]",
                 "",
                 "Page Title",
                 "http://www.arg-url.com/");
   }
 
   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",
                 "[\"vamoose\"]",
                 "http://www.google.com/",
                 "",
                 "");
     CheckAction(*actions->at(1).get(),
                 "punky",
                 Action::ACTION_API_CALL,
                 "brewster",
                 "[\"woof\"]",
                 "",
                 "",
                 "");
   }
 
-  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_API_CALL,
                 "lets",
                 "[\"vamoose\"]",
                 "",
                 "",
                 "");
     CheckAction(*actions->at(1).get(),
                 "punky",
                 Action::ACTION_DOM_ACCESS,
                 "lets",
                 "[\"vamoose\"]",
                 "",
                 "",
                 "");
   }
 
-  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",
                 "[\"vamoose\"]",
                 "http://www.google.com/",
                 "Google",
                 "http://www.args-url.com/");
@@ skipping 49 matching lines @@
     ASSERT_EQ(expected_arg_url, action.SerializeArgUrl());
     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(4, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky2",
                 Action::ACTION_API_CALL,
                 "lets2",
                 "[\"vamoose2\"]",
                 "http://www.google2.com/",
                 "Google2",
                 "http://www.args-url2.com/");
@@ skipping 20 matching lines @@
                 "punky1",
                 Action::ACTION_DOM_ACCESS,
                 "lets1",
                 "[\"vamoose1\"]",
                 "http://www.google1.com/",
                 "Google1",
                 "http://www.args-url1.com/");
     ASSERT_EQ(2, actions->at(3)->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(2, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky2",
                 Action::ACTION_API_CALL,
                 "lets2",
                 "[\"vamoose2\"]",
                 "http://www.google2.com/",
                 "Google2",
                 "http://www.args-url2.com/");
     ASSERT_EQ(3, actions->at(0)->action_id());
     CheckAction(*actions->at(1).get(),
                 "punky2",
                 Action::ACTION_API_CALL,
                 "lets2",
                 "[\"vamoose2\"]",
                 "http://www.google2.com/",
                 "Google2",
                 "http://www.args-url2.com/");
     ASSERT_EQ(4, actions->at(1)->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(2, static_cast<int>(actions->size()));
     CheckAction(*actions->at(0).get(),
                 "punky1",
                 Action::ACTION_DOM_ACCESS,
                 "lets1",
                 "[\"vamoose1\"]",
                 "http://www.google1.com/",
                 "Google1",
                 "http://www.args-url1.com/");
     ASSERT_EQ(1, actions->at(0)->action_id());
     CheckAction(*actions->at(1).get(),
                 "punky1",
                 Action::ACTION_DOM_ACCESS,
                 "lets1",
                 "[\"vamoose1\"]",
                 "http://www.google1.com/",
                 "Google1",
                 "http://www.args-url1.com/");
     ASSERT_EQ(2, actions->at(1)->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(FullStreamUIPolicyTest, Construct) {
   ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(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(FullStreamUIPolicyTest, LogAndFetchActions) {
   ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(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());
   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);
 
   CheckReadData(
       policy,
       extension->id(),
       0,
       base::Bind(&FullStreamUIPolicyTest::RetrieveActions_LogAndFetchActions));
 
   policy->Close();
@@ skipping 11 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 65 matching lines @@
   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,
                 extension->id(),
                 0,
                 base::Bind(&FullStreamUIPolicyTest::Arguments_Present));
   policy->Close();
 }
 
 TEST_F(FullStreamUIPolicyTest, GetTodaysActions) {
   ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(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.  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");
   action->set_arg_url(GURL("http://www.arg-url.com"));
   action->set_page_title("Page Title");
@@ skipping 25 matching lines @@
 // Check that we can read back less recent actions in the db.
 TEST_F(FullStreamUIPolicyTest, GetOlderActions) {
   ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(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() - base::TimeDelta::FromDays(3) -
                      base::TimeDelta::FromMinutes(40),
                  Action::ACTION_API_CALL,
                  "brewster");
   action->mutable_args()->AppendString("woof");
   policy->ProcessAction(action);
@@ skipping 32 matching lines @@
 
 TEST_F(FullStreamUIPolicyTest, RemoveAllURLs) {
   ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(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.google.com"));
   policy->ProcessAction(action);
@@ skipping 22 matching lines @@
 
 TEST_F(FullStreamUIPolicyTest, RemoveSpecificURLs) {
   ActivityLogDatabasePolicy* policy = new FullStreamUIPolicy(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 55 matching lines @@
 
 TEST_F(FullStreamUIPolicyTest, RemoveExtensionData) {
   FullStreamUIPolicy* policy = new FullStreamUIPolicy(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 80 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);
 
   CheckReadData(
       policy,
       extension->id(),
       0,
       base::Bind(&FullStreamUIPolicyTest::RetrieveActions_LogAndFetchActions));
 
   // Now delete them.
@@ skipping 61 matching lines @@
   action_ids.push_back(3);
   action_ids.push_back(4);
   CheckRemoveActions(
       policy, action_ids, base::Bind(&FullStreamUIPolicyTest::Action2Deleted));
   action_ids.clear();
 
   policy->Close();
 }
 
 }  // namespace extensions