[Extensions] Update generated code to support move operations

chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc

 // Copyright 2015 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 <utility>
 
+#include "base/callback_helpers.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/developer_private/extension_info_generator.h"
 #include "chrome/browser/extensions/api/developer_private/inspectable_views_finder.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 33 matching lines @@
  public:
   ExtensionInfoGeneratorUnitTest() {}
   ~ExtensionInfoGeneratorUnitTest() override {}
 
  protected:
   void SetUp() override {
     ExtensionServiceTestBase::SetUp();
     InitializeEmptyExtensionService();
   }
 
-  void OnInfosGenerated(linked_ptr<developer::ExtensionInfo>* info_out,
-                        const ExtensionInfoGenerator::ExtensionInfoList& list) {
+  void OnInfosGenerated(scoped_ptr<developer::ExtensionInfo>* info_out,
+                        ExtensionInfoGenerator::ExtensionInfoList list) {
     EXPECT_EQ(1u, list.size());
     if (!list.empty())
-      *info_out = list[0];
-    quit_closure_.Run();
-    quit_closure_.Reset();
+      info_out->reset(new developer::ExtensionInfo(std::move(list[0])));
+    base::ResetAndReturn(&quit_closure_).Run();
   }
 
   scoped_ptr<developer::ExtensionInfo> GenerateExtensionInfo(
       const std::string& extension_id) {
-    linked_ptr<developer::ExtensionInfo> info;
+    scoped_ptr<developer::ExtensionInfo> info;
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     scoped_ptr<ExtensionInfoGenerator> generator(
         new ExtensionInfoGenerator(browser_context()));
     generator->CreateExtensionInfo(
         extension_id,
         base::Bind(&ExtensionInfoGeneratorUnitTest::OnInfosGenerated,
                    base::Unretained(this),
                    base::Unretained(&info)));
     run_loop.Run();
-    return make_scoped_ptr(info.release());
+    return info;
   }
 
   const scoped_refptr<const Extension> CreateExtension(
       const std::string& name,
       scoped_ptr<base::ListValue> permissions) {
     const std::string kId = crx_file::id_util::GenerateId(name);
     scoped_refptr<const Extension> extension =
         ExtensionBuilder()
             .SetManifest(DictionaryBuilder()
                              .Set("name", name)
@@ skipping 26 matching lines @@
         &error));
     CHECK(extension.get());
     service()->AddExtension(extension.get());
     EXPECT_EQ(std::string(), error);
 
     return GenerateExtensionInfo(extension->id());
   }
 
   void CompareExpectedAndActualOutput(
       const base::FilePath& extension_path,
-      const InspectableViewsFinder::ViewList& views,
+      InspectableViewsFinder::ViewList views,
       const base::FilePath& expected_output_path) {
     std::string error;
     scoped_ptr<base::DictionaryValue> expected_output_data(
         DeserializeJSONTestData(expected_output_path, &error));
     EXPECT_EQ(std::string(), error);
 
     // Produce test output.
     scoped_ptr<developer::ExtensionInfo> info =
         CreateExtensionInfoFromPath(extension_path, Manifest::INVALID_LOCATION);
-    info->views = views;
+    info->views = std::move(views);
     scoped_ptr<base::DictionaryValue> actual_output_data = info->ToValue();
     ASSERT_TRUE(actual_output_data);
 
     // Compare the outputs.
     // Ignore unknown fields in the actual output data.
     std::string paths_details = " - expected (" +
         expected_output_path.MaybeAsASCII() + ") vs. actual (" +
         extension_path.MaybeAsASCII() + ")";
     std::string expected_string;
     std::string actual_string;
@@ skipping 96 matching lines @@
   ASSERT_TRUE(info->path);
   EXPECT_EQ(data_dir(), base::FilePath::FromUTF8Unsafe(*info->path));
   EXPECT_EQ(api::developer_private::EXTENSION_STATE_ENABLED, info->state);
   EXPECT_EQ(api::developer_private::EXTENSION_TYPE_EXTENSION, info->type);
   EXPECT_TRUE(info->file_access.is_enabled);
   EXPECT_FALSE(info->file_access.is_active);
   EXPECT_TRUE(info->incognito_access.is_enabled);
   EXPECT_FALSE(info->incognito_access.is_active);
   ASSERT_EQ(2u, info->runtime_errors.size());
   const api::developer_private::RuntimeError& runtime_error =
-      *info->runtime_errors[0];
+      info->runtime_errors[0];
   EXPECT_EQ(extension->id(), runtime_error.extension_id);
   EXPECT_EQ(api::developer_private::ERROR_TYPE_RUNTIME, runtime_error.type);
   EXPECT_EQ(api::developer_private::ERROR_LEVEL_ERROR,
             runtime_error.severity);
   EXPECT_EQ(1u, runtime_error.stack_trace.size());
   ASSERT_EQ(1u, info->manifest_errors.size());
   const api::developer_private::RuntimeError& runtime_error_verbose =
-      *info->runtime_errors[1];
+      info->runtime_errors[1];
   EXPECT_EQ(api::developer_private::ERROR_LEVEL_LOG,
             runtime_error_verbose.severity);
   const api::developer_private::ManifestError& manifest_error =
-      *info->manifest_errors[0];
+      info->manifest_errors[0];
   EXPECT_EQ(extension->id(), manifest_error.extension_id);
 
   // Test an extension that isn't unpacked.
   manifest_copy->SetString("update_url",
                            "https://clients2.google.com/service/update2/crx");
   id = crx_file::id_util::GenerateId("beta");
   extension = ExtensionBuilder()
                   .SetManifest(std::move(manifest_copy))
                   .SetLocation(Manifest::EXTERNAL_PREF)
                   .SetID(id)
                   .Build();
   service()->AddExtension(extension.get());
   info = GenerateExtensionInfo(extension->id());
   EXPECT_EQ(developer::LOCATION_THIRD_PARTY, info->location);
   EXPECT_FALSE(info->path);
 }
 
 // Test three generated json outputs.
 TEST_F(ExtensionInfoGeneratorUnitTest, GenerateExtensionsJSONData) {
   // Test Extension1
   base::FilePath extension_path =
       data_dir().AppendASCII("good")
                 .AppendASCII("Extensions")
                 .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
                 .AppendASCII("1.0.0.0");
 
-  InspectableViewsFinder::ViewList views;
-  views.push_back(InspectableViewsFinder::ConstructView(
-      GURL("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/bar.html"),
-      42, 88, true, false, VIEW_TYPE_TAB_CONTENTS));
-  views.push_back(InspectableViewsFinder::ConstructView(
-      GURL("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/dog.html"),
-      0, 0, false, true, VIEW_TYPE_TAB_CONTENTS));
-
   base::FilePath expected_outputs_path =
       data_dir().AppendASCII("api_test")
                 .AppendASCII("developer")
                 .AppendASCII("generated_output");
 
-  CompareExpectedAndActualOutput(
-      extension_path,
-      views,
-      expected_outputs_path.AppendASCII(
-          "behllobkkfkfnphdnhnkndlbkcpglgmj.json"));
+  {
+    InspectableViewsFinder::ViewList views;
+    views.push_back(InspectableViewsFinder::ConstructView(
+        GURL("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/bar.html"),
+        42, 88, true, false, VIEW_TYPE_TAB_CONTENTS));
+    views.push_back(InspectableViewsFinder::ConstructView(
+        GURL("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/dog.html"), 0,
+        0, false, true, VIEW_TYPE_TAB_CONTENTS));
+
+    CompareExpectedAndActualOutput(
+        extension_path, std::move(views),
+        expected_outputs_path.AppendASCII(
+            "behllobkkfkfnphdnhnkndlbkcpglgmj.json"));
+  }
 
 #if !defined(OS_CHROMEOS)
   // Test Extension2
   extension_path = data_dir().AppendASCII("good")
                              .AppendASCII("Extensions")
                              .AppendASCII("hpiknbiabeeppbpihjehijgoemciehgk")
                              .AppendASCII("2");
 
-  // It's OK to have duplicate URLs, so long as the IDs are different.
-  views[0]->url =
-      "chrome-extension://hpiknbiabeeppbpihjehijgoemciehgk/bar.html";
-  views[1]->url = views[0]->url;
+  {
+    // It's OK to have duplicate URLs, so long as the IDs are different.
+    InspectableViewsFinder::ViewList views;
+    views.push_back(InspectableViewsFinder::ConstructView(
+        GURL("chrome-extension://hpiknbiabeeppbpihjehijgoemciehgk/bar.html"),
+        42, 88, true, false, VIEW_TYPE_TAB_CONTENTS));
+    views.push_back(InspectableViewsFinder::ConstructView(
+        GURL("chrome-extension://hpiknbiabeeppbpihjehijgoemciehgk/bar.html"), 0,
+        0, false, true, VIEW_TYPE_TAB_CONTENTS));
 
-  CompareExpectedAndActualOutput(
-      extension_path,
-      views,
-      expected_outputs_path.AppendASCII(
-          "hpiknbiabeeppbpihjehijgoemciehgk.json"));
+    CompareExpectedAndActualOutput(
+        extension_path, std::move(views),
+        expected_outputs_path.AppendASCII(
+            "hpiknbiabeeppbpihjehijgoemciehgk.json"));
+  }
 #endif
 
   // Test Extension3
   extension_path = data_dir().AppendASCII("good")
                              .AppendASCII("Extensions")
                              .AppendASCII("bjafgdebaacbbbecmhlhpofkepfkgcpa")
                              .AppendASCII("1.0");
-  views.clear();
-
-  CompareExpectedAndActualOutput(
-      extension_path,
-      views,
-      expected_outputs_path.AppendASCII(
-          "bjafgdebaacbbbecmhlhpofkepfkgcpa.json"));
+  CompareExpectedAndActualOutput(extension_path,
+                                 InspectableViewsFinder::ViewList(),
+                                 expected_outputs_path.AppendASCII(
+                                     "bjafgdebaacbbbecmhlhpofkepfkgcpa.json"));
 }
 
 // Test that the all_urls checkbox only shows up for extensions that want all
 // urls, and only when the switch is on.
 TEST_F(ExtensionInfoGeneratorUnitTest, ExtensionInfoRunOnAllUrls) {
   // Start with the switch enabled.
   scoped_ptr<FeatureSwitch::ScopedOverride> enable_scripts_switch(
       new FeatureSwitch::ScopedOverride(
           FeatureSwitch::scripts_require_action(), true));
   // Two extensions - one with all urls, one without.
@@ skipping 48 matching lines @@
       "all_urls_II", ListBuilder().Append(kAllHostsPermission).Build());
 
   // Even though the extension has all_urls permission, the checkbox shouldn't
   // show up without the switch.
   info = GenerateExtensionInfo(all_urls_extension->id());
   EXPECT_FALSE(info->run_on_all_urls.is_enabled);
   EXPECT_TRUE(info->run_on_all_urls.is_active);
 }
 
 }  // namespace extensions