Remove some linked_ptr c/b/extension

chrome/browser/extensions/extension_action_runner_browsertest.cc

 // Copyright 2014 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/extension_action_runner.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 166 matching lines @@
  public:
   ActiveScriptTester(const std::string& name,
                      const Extension* extension,
                      Browser* browser,
                      RequiresConsent requires_consent,
                      InjectionType type);
   ~ActiveScriptTester();
 
   testing::AssertionResult Verify();
 
+  std::string name() const;
+
  private:
   // Returns the ExtensionActionRunner, or null if one does not exist.
   ExtensionActionRunner* GetExtensionActionRunner();
 
   // Returns true if the extension has a pending request with the
   // ExtensionActionRunner.
   bool WantsToRun();
 
   // The name of the extension, and also the message it sends.
   std::string name_;
 
   // The extension associated with this tester.
   const Extension* extension_;
 
   // The browser the tester is running in.
   Browser* browser_;
 
   // Whether or not the extension has permission to run the script without
   // asking the user.
   RequiresConsent requires_consent_;
 
-  // The type of injection this tester uses.
-  InjectionType type_;
-
   // All of these extensions should inject a script (either through content
   // scripts or through chrome.tabs.executeScript()) that sends a message with
   // the |kInjectSucceeded| message.
-  linked_ptr<ExtensionTestMessageListener> inject_success_listener_;
+  std::unique_ptr<ExtensionTestMessageListener> inject_success_listener_;
 };
 
 ActiveScriptTester::ActiveScriptTester(const std::string& name,
                                        const Extension* extension,
                                        Browser* browser,
                                        RequiresConsent requires_consent,
                                        InjectionType type)
     : name_(name),
       extension_(extension),
       browser_(browser),
       requires_consent_(requires_consent),
-      type_(type),
       inject_success_listener_(
           new ExtensionTestMessageListener(kInjectSucceeded,
                                            false /* won't reply */)) {
   inject_success_listener_->set_extension_id(extension->id());
 }
 
 ActiveScriptTester::~ActiveScriptTester() {}
 
+std::string ActiveScriptTester::name() const {
+  return name_;
+}
+
 testing::AssertionResult ActiveScriptTester::Verify() {
   if (!extension_)
     return testing::AssertionFailure() << "Could not load extension: " << name_;
 
   content::WebContents* web_contents =
       browser_ ? browser_->tab_strip_model()->GetActiveWebContents() : NULL;
   if (!web_contents)
     return testing::AssertionFailure() << "No web contents.";
 
   // Give the extension plenty of time to inject.
@@ skipping 56 matching lines @@
       browser_ ? browser_->tab_strip_model()->GetActiveWebContents() : nullptr);
 }
 
 bool ActiveScriptTester::WantsToRun() {
   ExtensionActionRunner* runner = GetExtensionActionRunner();
   return runner ? runner->WantsToRun(extension_) : false;
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionActionRunnerBrowserTest,
                        ActiveScriptsAreDisplayedAndDelayExecution) {
-  base::FilePath active_script_path =
-      test_data_dir_.AppendASCII("active_script");
-
-  const char* const kExtensionNames[] = {
-      "inject_scripts_all_hosts", "inject_scripts_explicit_hosts",
-      "content_scripts_all_hosts", "content_scripts_explicit_hosts"};
-
   // First, we load up three extensions:
   // - An extension that injects scripts into all hosts,
   // - An extension that injects scripts into explicit hosts,
   // - An extension with a content script that runs on all hosts,
   // - An extension with a content script that runs on explicit hosts.
   // The extensions that operate on explicit hosts have permission; the ones
   // that request all hosts require user consent.
-  ActiveScriptTester testers[] = {
-      ActiveScriptTester(kExtensionNames[0],
-                         CreateExtension(ALL_HOSTS, EXECUTE_SCRIPT), browser(),
-                         REQUIRES_CONSENT, EXECUTE_SCRIPT),
-      ActiveScriptTester(kExtensionNames[1],
-                         CreateExtension(EXPLICIT_HOSTS, EXECUTE_SCRIPT),
-                         browser(), DOES_NOT_REQUIRE_CONSENT, EXECUTE_SCRIPT),
-      ActiveScriptTester(kExtensionNames[2],
-                         CreateExtension(ALL_HOSTS, CONTENT_SCRIPT), browser(),
-                         REQUIRES_CONSENT, CONTENT_SCRIPT),
-      ActiveScriptTester(kExtensionNames[3],
-                         CreateExtension(EXPLICIT_HOSTS, CONTENT_SCRIPT),
-                         browser(), DOES_NOT_REQUIRE_CONSENT, CONTENT_SCRIPT),
-  };
+  std::vector<std::unique_ptr<ActiveScriptTester>> testers;
+  testers.push_back(base::MakeUnique<ActiveScriptTester>(
+      "inject_scripts_all_hosts", CreateExtension(ALL_HOSTS, EXECUTE_SCRIPT),
+      browser(), REQUIRES_CONSENT, EXECUTE_SCRIPT));
+  testers.push_back(base::MakeUnique<ActiveScriptTester>(
+      "inject_scripts_explicit_hosts",
+      CreateExtension(EXPLICIT_HOSTS, EXECUTE_SCRIPT), browser(),
+      DOES_NOT_REQUIRE_CONSENT, EXECUTE_SCRIPT));
+  testers.push_back(base::MakeUnique<ActiveScriptTester>(
+      "content_scripts_all_hosts", CreateExtension(ALL_HOSTS, CONTENT_SCRIPT),
+      browser(), REQUIRES_CONSENT, CONTENT_SCRIPT));
+  testers.push_back(base::MakeUnique<ActiveScriptTester>(
+      "content_scripts_explicit_hosts",
+      CreateExtension(EXPLICIT_HOSTS, CONTENT_SCRIPT), browser(),
+      DOES_NOT_REQUIRE_CONSENT, CONTENT_SCRIPT));
 
   // Navigate to an URL (which matches the explicit host specified in the
   // extension content_scripts_explicit_hosts). All four extensions should
   // inject the script.
   ASSERT_TRUE(embedded_test_server()->Start());
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
 
-  for (size_t i = 0u; i < arraysize(testers); ++i)
-    EXPECT_TRUE(testers[i].Verify()) << kExtensionNames[i];
+  for (const auto& tester : testers)
+    EXPECT_TRUE(tester->Verify()) << tester->name();
 }
 
 // Test that removing an extension with pending injections a) removes the
 // pending injections for that extension, and b) does not affect pending
 // injections for other extensions.
 IN_PROC_BROWSER_TEST_F(ExtensionActionRunnerBrowserTest,
                        RemoveExtensionWithPendingInjections) {
   // Load up two extensions, each with content scripts.
   const Extension* extension1 = CreateExtension(ALL_HOSTS, CONTENT_SCRIPT);
   ASSERT_TRUE(extension1);
@@ skipping 182 matching lines @@
     : public ExtensionActionRunnerBrowserTest {
  private:
   // Simply don't append the flag.
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionBrowserTest::SetUpCommandLine(command_line);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(FlagOffExtensionActionRunnerBrowserTest,
                        ScriptsExecuteWhenFlagAbsent) {
-  const char* const kExtensionNames[] = {
-      "content_scripts_all_hosts", "inject_scripts_all_hosts",
-  };
-  ActiveScriptTester testers[] = {
-      ActiveScriptTester(kExtensionNames[0],
-                         CreateExtension(ALL_HOSTS, CONTENT_SCRIPT), browser(),
-                         DOES_NOT_REQUIRE_CONSENT, CONTENT_SCRIPT),
-      ActiveScriptTester(kExtensionNames[1],
-                         CreateExtension(ALL_HOSTS, EXECUTE_SCRIPT), browser(),
-                         DOES_NOT_REQUIRE_CONSENT, EXECUTE_SCRIPT),
-  };
+  std::vector<std::unique_ptr<ActiveScriptTester>> testers;
+  testers.push_back(base::MakeUnique<ActiveScriptTester>(
+      "content_scripts_all_hosts", CreateExtension(ALL_HOSTS, CONTENT_SCRIPT),
+      browser(), DOES_NOT_REQUIRE_CONSENT, CONTENT_SCRIPT));
+  testers.push_back(base::MakeUnique<ActiveScriptTester>(
+      "inject_scripts_all_hosts", CreateExtension(ALL_HOSTS, EXECUTE_SCRIPT),
+      browser(), DOES_NOT_REQUIRE_CONSENT, EXECUTE_SCRIPT));
 
   ASSERT_TRUE(embedded_test_server()->Start());
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/extensions/test_file.html"));
 
-  for (size_t i = 0u; i < arraysize(testers); ++i)
-    EXPECT_TRUE(testers[i].Verify()) << kExtensionNames[i];
+  for (const auto& tester : testers)
+    EXPECT_TRUE(tester->Verify()) << tester->name();
 }
 
 }  // namespace extensions