[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

[asargent_no_longer_on_chrome, 2016/03/21 21:03:13]

is this part of the comment about "vector of linked ptrs" still accurate? (not
sure if it's referring to the ExtensionInfoGenerator::ExtensionInfoList or some
elements within it)

[Devlin, 2016/03/21 22:24:27]

Good call!  We can actually completely remove this hack. :)

     // here is, well, messy. Easier to just set it like this.
     dict->SetWithoutPathExpansion("extensionInfo",
-                                  infos[0]->ToValue().release());
+                                  infos[0].ToValue().release());
   }
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(dict.release());
   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));
 }
 
@@ skipping 87 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