[Extensions] Update generated code to support move operations

chrome/browser/extensions/api/developer_private/extension_info_generator.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 "chrome/browser/extensions/api/developer_private/extension_info_generator.h"
 
 #include <utility>
 
 #include "base/base64.h"
+#include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/extensions/api/developer_private/inspectable_views_finder.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_ui_util.h"
@@ skipping 76 matching lines @@
       developer::ERROR_TYPE_MANIFEST : developer::ERROR_TYPE_RUNTIME;
   out->extension_id = error.extension_id();
   out->from_incognito = error.from_incognito();
   out->source = base::UTF16ToUTF8(error.source());
   out->message = base::UTF16ToUTF8(error.message());
   out->id = error.id();
 }
 
 // Given a ManifestError object, converts it into its developer_private
 // counterpart.
-linked_ptr<developer::ManifestError> ConstructManifestError(
-    const ManifestError& error) {
-  linked_ptr<developer::ManifestError> result(new developer::ManifestError());
-  PopulateErrorBase(error, result.get());
-  result->manifest_key = base::UTF16ToUTF8(error.manifest_key());
+developer::ManifestError ConstructManifestError(const ManifestError& error) {
+  developer::ManifestError result;
+  PopulateErrorBase(error, &result);
+  result.manifest_key = base::UTF16ToUTF8(error.manifest_key());
   if (!error.manifest_specific().empty()) {
-    result->manifest_specific.reset(
+    result.manifest_specific.reset(
         new std::string(base::UTF16ToUTF8(error.manifest_specific())));
   }
   return result;
 }
 
 // Given a RuntimeError object, converts it into its developer_private
 // counterpart.
-linked_ptr<developer::RuntimeError> ConstructRuntimeError(
-    const RuntimeError& error) {
-  linked_ptr<developer::RuntimeError> result(new developer::RuntimeError());
-  PopulateErrorBase(error, result.get());
+developer::RuntimeError ConstructRuntimeError(const RuntimeError& error) {
+  developer::RuntimeError result;
+  PopulateErrorBase(error, &result);
   switch (error.level()) {
     case logging::LOG_VERBOSE:
     case logging::LOG_INFO:
-      result->severity = developer::ERROR_LEVEL_LOG;
+      result.severity = developer::ERROR_LEVEL_LOG;
       break;
     case logging::LOG_WARNING:
-      result->severity = developer::ERROR_LEVEL_WARN;
+      result.severity = developer::ERROR_LEVEL_WARN;
       break;
     case logging::LOG_FATAL:
     case logging::LOG_ERROR:
-      result->severity = developer::ERROR_LEVEL_ERROR;
+      result.severity = developer::ERROR_LEVEL_ERROR;
       break;
     default:
       NOTREACHED();
   }
-  result->occurrences = error.occurrences();
+  result.occurrences = error.occurrences();
   // NOTE(devlin): This is called "render_view_id" in the api for legacy
   // reasons, but it's not a high priority to change.
-  result->render_view_id = error.render_frame_id();
-  result->render_process_id = error.render_process_id();
-  result->can_inspect =
+  result.render_view_id = error.render_frame_id();
+  result.render_process_id = error.render_process_id();
+  result.can_inspect =
       content::RenderFrameHost::FromID(error.render_process_id(),
                                        error.render_frame_id()) != nullptr;
   for (const StackFrame& f : error.stack_trace()) {
-    linked_ptr<developer::StackFrame> frame(new developer::StackFrame());
-    frame->line_number = f.line_number;
-    frame->column_number = f.column_number;
-    frame->url = base::UTF16ToUTF8(f.source);
-    frame->function_name = base::UTF16ToUTF8(f.function);
-    result->stack_trace.push_back(frame);
+    developer::StackFrame frame;
+    frame.line_number = f.line_number;
+    frame.column_number = f.column_number;
+    frame.url = base::UTF16ToUTF8(f.source);
+    frame.function_name = base::UTF16ToUTF8(f.function);
+    result.stack_trace.push_back(std::move(frame));
   }
   return result;
 }
 
 // Constructs any commands for the extension with the given |id|, and adds them
 // to the list of |commands|.
 void ConstructCommands(CommandService* command_service,
                        const std::string& extension_id,
-                       std::vector<linked_ptr<developer::Command>>* commands) {
-  auto construct_command = [](const Command& command,
-                              bool active,
+                       std::vector<developer::Command>* commands) {
+  auto construct_command = [](const Command& command, bool active,
                               bool is_extension_action) {
-    developer::Command* command_value = new developer::Command();
-    command_value->description = is_extension_action ?
-        l10n_util::GetStringUTF8(IDS_EXTENSION_COMMANDS_GENERIC_ACTIVATE) :
-        base::UTF16ToUTF8(command.description());
-    command_value->keybinding =
+    developer::Command command_value;
+    command_value.description =
+        is_extension_action
+            ? l10n_util::GetStringUTF8(IDS_EXTENSION_COMMANDS_GENERIC_ACTIVATE)
+            : base::UTF16ToUTF8(command.description());
+    command_value.keybinding =
         base::UTF16ToUTF8(command.accelerator().GetShortcutText());
-    command_value->name = command.command_name();
-    command_value->is_active = active;
-    command_value->scope = command.global() ? developer::COMMAND_SCOPE_GLOBAL :
-        developer::COMMAND_SCOPE_CHROME;
-    command_value->is_extension_action = is_extension_action;
+    command_value.name = command.command_name();
+    command_value.is_active = active;
+    command_value.scope = command.global() ? developer::COMMAND_SCOPE_GLOBAL
+                                           : developer::COMMAND_SCOPE_CHROME;
+    command_value.is_extension_action = is_extension_action;
     return command_value;
   };
   bool active = false;
   Command browser_action;
   if (command_service->GetBrowserActionCommand(extension_id,
                                                CommandService::ALL,
                                                &browser_action,
                                                &active)) {
-    commands->push_back(
-        make_linked_ptr(construct_command(browser_action, active, true)));
+    commands->push_back(construct_command(browser_action, active, true));
   }
 
   Command page_action;
   if (command_service->GetPageActionCommand(extension_id,
                                             CommandService::ALL,
                                             &page_action,
                                             &active)) {
-    commands->push_back(
-        make_linked_ptr(construct_command(page_action, active, true)));
+    commands->push_back(construct_command(page_action, active, true));
   }
 
   CommandMap named_commands;
   if (command_service->GetNamedCommands(extension_id,
                                         CommandService::ALL,
                                         CommandService::ANY_SCOPE,
                                         &named_commands)) {
     for (auto& pair : named_commands) {
       Command& command_to_use = pair.second;
       // TODO(devlin): For some reason beyond my knowledge, FindCommandByName
       // returns different data than GetNamedCommands, including the
       // accelerators, but not the descriptions - and even then, only if the
       // command is active.
       // Unfortunately, some systems may be relying on the other data (which
       // more closely matches manifest data).
       // Until we can sort all this out, we merge the two command structures.
       Command active_command = command_service->FindCommandByName(
           extension_id, command_to_use.command_name());
       command_to_use.set_accelerator(active_command.accelerator());
       command_to_use.set_global(active_command.global());
       bool active = command_to_use.accelerator().key_code() != ui::VKEY_UNKNOWN;
-      commands->push_back(
-          make_linked_ptr(construct_command(command_to_use, active, false)));
+      commands->push_back(construct_command(command_to_use, active, false));
     }
   }
 }
 
 }  // namespace
 
 ExtensionInfoGenerator::ExtensionInfoGenerator(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context),
       command_service_(CommandService::Get(browser_context)),
@@ skipping 24 matching lines @@
   else if ((ext = registry->disabled_extensions().GetByID(id)) != nullptr)
     state = developer::EXTENSION_STATE_DISABLED;
   else if ((ext = registry->terminated_extensions().GetByID(id)) != nullptr)
     state = developer::EXTENSION_STATE_TERMINATED;
 
   if (ext && ui_util::ShouldDisplayInExtensionSettings(ext, browser_context_))
     CreateExtensionInfoHelper(*ext, state);
 
   if (pending_image_loads_ == 0) {
     // Don't call the callback re-entrantly.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  base::Bind(callback, list_));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, base::Passed(&list_)));
     list_.clear();
   } else {
     callback_ = callback;
   }
 }
 
 void ExtensionInfoGenerator::CreateExtensionsInfo(
     bool include_disabled,
     bool include_terminated,
     const ExtensionInfosCallback& callback) {
@@ skipping 14 matching lines @@
     add_to_list(registry->disabled_extensions(),
                 developer::EXTENSION_STATE_DISABLED);
   }
   if (include_terminated) {
     add_to_list(registry->terminated_extensions(),
                 developer::EXTENSION_STATE_TERMINATED);
   }
 
   if (pending_image_loads_ == 0) {
     // Don't call the callback re-entrantly.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  base::Bind(callback, list_));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, base::Passed(&list_)));
     list_.clear();
   } else {
     callback_ = callback;
   }
 }
 
 void ExtensionInfoGenerator::CreateExtensionInfoHelper(
     const Extension& extension,
     developer::ExtensionState state) {
   scoped_ptr<developer::ExtensionInfo> info(new developer::ExtensionInfo());
@@ skipping 222 matching lines @@
                       GetViewsForExtension(extension, is_enabled);
   }
 
   // The icon.
   ExtensionResource icon =
       IconsInfo::GetIconResource(&extension,
                                  extension_misc::EXTENSION_ICON_MEDIUM,
                                  ExtensionIconSet::MATCH_BIGGER);
   if (icon.empty()) {
     info->icon_url = GetDefaultIconUrl(extension.is_app(), !is_enabled);
-    list_.push_back(make_linked_ptr(info.release()));
+    list_.push_back(std::move(*info));
   } else {
     ++pending_image_loads_;
     // Max size of 128x128 is a random guess at a nice balance between being
     // overly eager to resize and sending across gigantic data urls. (The icon
     // used by the url is 48x48).
     gfx::Size max_size(128, 128);
     image_loader_->LoadImageAsync(
         &extension, icon, max_size,
         base::Bind(&ExtensionInfoGenerator::OnImageLoaded,
-                   weak_factory_.GetWeakPtr(), base::Passed(std::move(info))));
+                   weak_factory_.GetWeakPtr(), base::Passed(&info)));
   }
 }
 
 const std::string& ExtensionInfoGenerator::GetDefaultIconUrl(
     bool is_app,
     bool is_greyscale) {
   std::string* str;
   if (is_app) {
     str = is_greyscale ? &default_disabled_app_icon_url_ :
         &default_app_icon_url_;
@@ skipping 44 matching lines @@
         icon, info->state != developer::EXTENSION_STATE_ENABLED);
   } else {
     bool is_app =
         info->type == developer::EXTENSION_TYPE_HOSTED_APP ||
         info->type == developer::EXTENSION_TYPE_LEGACY_PACKAGED_APP ||
         info->type == developer::EXTENSION_TYPE_PLATFORM_APP;
     info->icon_url = GetDefaultIconUrl(
         is_app, info->state != developer::EXTENSION_STATE_ENABLED);
   }
 
-  list_.push_back(make_linked_ptr(info.release()));
+  list_.push_back(std::move(*info));
 
   --pending_image_loads_;
 
   if (pending_image_loads_ == 0) {  // All done!
-    // We assign to a temporary callback and list and reset the stored values so
-    // that at the end of the method, any stored refs are destroyed.
-    ExtensionInfoList list;
-    list.swap(list_);
-    ExtensionInfosCallback callback = callback_;
-    callback_.Reset();
-    callback.Run(list);  // WARNING: |this| is possibly deleted after this line!
+    ExtensionInfoList list = std::move(list_);
+    list_.clear();
+    base::ResetAndReturn(&callback_).Run(std::move(list));
+    // WARNING: |this| is possibly deleted after this line!
   }
 }
 
 }  // namespace extensions