[Extensions] Update generated code to support move operations

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

 // Copyright (c) 2012 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/api/developer_private/developer_private_api.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 370 matching lines @@
       extension_id,
       base::Bind(&DeveloperPrivateEventRouter::BroadcastItemStateChangedHelper,
                  weak_factory_.GetWeakPtr(), event_type, extension_id,
                  base::Passed(std::move(info_generator))));
 }
 
 void DeveloperPrivateEventRouter::BroadcastItemStateChangedHelper(
     developer::EventType event_type,
     const std::string& extension_id,
     scoped_ptr<ExtensionInfoGenerator> info_generator,
-    const ExtensionInfoGenerator::ExtensionInfoList& infos) {
+    ExtensionInfoGenerator::ExtensionInfoList infos) {
   DCHECK_LE(infos.size(), 1u);
 
   developer::EventData event_data;
   event_data.event_type = event_type;
   event_data.item_id = extension_id;
-  scoped_ptr<base::DictionaryValue> dict = event_data.ToValue();
-
   if (!infos.empty()) {
-    // Hack: Ideally, we would use event_data.extension_info to set the
-    // extension info, but since it's an optional field, it's implemented as a
-    // scoped ptr, and so ownership between that and the vector of linked ptrs
-    // here is, well, messy. Easier to just set it like this.
-    dict->SetWithoutPathExpansion("extensionInfo",
-                                  infos[0]->ToValue().release());
+    event_data.extension_info.reset(
+        new developer::ExtensionInfo(std::move(infos[0])));
   }
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(dict.release());
+  args->Append(event_data.ToValue());
   scoped_ptr<Event> event(
       new Event(events::DEVELOPER_PRIVATE_ON_ITEM_STATE_CHANGED,
                 developer::OnItemStateChanged::kEventName, std::move(args)));
   event_router_->BroadcastEvent(std::move(event));
 }
 
 void DeveloperPrivateAPI::SetLastUnpackedDirectory(const base::FilePath& path) {
   last_unpacked_directory_ = path;
 }
 
@@ skipping 83 matching lines @@
   info_generator_->CreateExtensionsInfo(
       include_disabled,
       include_terminated,
       base::Bind(&DeveloperPrivateGetExtensionsInfoFunction::OnInfosGenerated,
                  this /* refcounted */));
 
   return RespondLater();
 }
 
 void DeveloperPrivateGetExtensionsInfoFunction::OnInfosGenerated(
-    const ExtensionInfoGenerator::ExtensionInfoList& list) {
+    ExtensionInfoGenerator::ExtensionInfoList list) {
   Respond(ArgumentList(developer::GetExtensionsInfo::Results::Create(list)));
 }
 
 DeveloperPrivateGetExtensionInfoFunction::
 DeveloperPrivateGetExtensionInfoFunction() {
 }
 
 DeveloperPrivateGetExtensionInfoFunction::
 ~DeveloperPrivateGetExtensionInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetExtensionInfoFunction::Run() {
   scoped_ptr<developer::GetExtensionInfo::Params> params(
       developer::GetExtensionInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   info_generator_.reset(new ExtensionInfoGenerator(browser_context()));
   info_generator_->CreateExtensionInfo(
       params->id,
       base::Bind(&DeveloperPrivateGetExtensionInfoFunction::OnInfosGenerated,
                  this /* refcounted */));
 
   return RespondLater();
 }
 
 void DeveloperPrivateGetExtensionInfoFunction::OnInfosGenerated(
-    const ExtensionInfoGenerator::ExtensionInfoList& list) {
-  DCHECK_EQ(1u, list.size());
-  const linked_ptr<developer::ExtensionInfo>& info = list[0];
-  Respond(info.get() ? OneArgument(info->ToValue()) :
-      Error(kNoSuchExtensionError));
+    ExtensionInfoGenerator::ExtensionInfoList list) {
+  DCHECK_LE(1u, list.size());
+  Respond(list.empty() ? Error(kNoSuchExtensionError)
+                       : OneArgument(list[0].ToValue()));
 }
 
 DeveloperPrivateGetItemsInfoFunction::DeveloperPrivateGetItemsInfoFunction() {}
 DeveloperPrivateGetItemsInfoFunction::~DeveloperPrivateGetItemsInfoFunction() {}
 
 ExtensionFunction::ResponseAction DeveloperPrivateGetItemsInfoFunction::Run() {
   scoped_ptr<developer::GetItemsInfo::Params> params(
       developer::GetItemsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   info_generator_.reset(new ExtensionInfoGenerator(browser_context()));
   info_generator_->CreateExtensionsInfo(
       params->include_disabled,
       params->include_terminated,
       base::Bind(&DeveloperPrivateGetItemsInfoFunction::OnInfosGenerated,
                  this /* refcounted */));
 
   return RespondLater();
 }
 
 void DeveloperPrivateGetItemsInfoFunction::OnInfosGenerated(
-    const ExtensionInfoGenerator::ExtensionInfoList& list) {
-  std::vector<linked_ptr<developer::ItemInfo>> item_list;
-  for (const linked_ptr<developer::ExtensionInfo>& info : list)
-    item_list.push_back(developer_private_mangle::MangleExtensionInfo(*info));
+    ExtensionInfoGenerator::ExtensionInfoList list) {
+  std::vector<developer::ItemInfo> item_list;
+  for (const developer::ExtensionInfo& info : list)
+    item_list.push_back(developer_private_mangle::MangleExtensionInfo(info));
 
   Respond(ArgumentList(developer::GetItemsInfo::Results::Create(item_list)));
 }
 
 DeveloperPrivateGetProfileConfigurationFunction::
 ~DeveloperPrivateGetProfileConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetProfileConfigurationFunction::Run() {
@@ skipping 869 matching lines @@
         update.extension_id, update.command_name, *update.keybinding);
   }
 
   return RespondNow(NoArguments());
 }
 
 
 }  // namespace api
 
 }  // namespace extensions