[Extensions] Update generated code to support move operations

chrome/browser/extensions/api/developer_private/developer_private_mangle.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/developer_private_mangle.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/common/extensions/api/developer_private.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/common/constants.h"
 
 namespace extensions {
 namespace developer_private_mangle {
 
-linked_ptr<api::developer_private::ItemInfo> MangleExtensionInfo(
+api::developer_private::ItemInfo MangleExtensionInfo(
     const api::developer_private::ExtensionInfo& info) {
-  linked_ptr<api::developer_private::ItemInfo> result(
-      new api::developer_private::ItemInfo());
-  result->id = info.id;
-  result->name = info.name;
-  result->version = info.version;
-  result->description = info.description;
-  result->may_disable = info.user_may_modify;
-  result->enabled =
+  api::developer_private::ItemInfo result;
+  result.id = info.id;
+  result.name = info.name;
+  result.version = info.version;
+  result.description = info.description;
+  result.may_disable = info.user_may_modify;
+  result.enabled =
       info.state == api::developer_private::EXTENSION_STATE_ENABLED;
   switch (info.type) {
     case api::developer_private::EXTENSION_TYPE_HOSTED_APP:
-      result->type = api::developer_private::ITEM_TYPE_HOSTED_APP;
-      result->is_app = true;
+      result.type = api::developer_private::ITEM_TYPE_HOSTED_APP;
+      result.is_app = true;
       break;
     case api::developer_private::EXTENSION_TYPE_PLATFORM_APP:
-      result->type = api::developer_private::ITEM_TYPE_PACKAGED_APP;
-      result->is_app = true;
+      result.type = api::developer_private::ITEM_TYPE_PACKAGED_APP;
+      result.is_app = true;
       break;
     case api::developer_private::EXTENSION_TYPE_LEGACY_PACKAGED_APP:
-      result->type = api::developer_private::ITEM_TYPE_LEGACY_PACKAGED_APP;
-      result->is_app = true;
+      result.type = api::developer_private::ITEM_TYPE_LEGACY_PACKAGED_APP;
+      result.is_app = true;
       break;
     case api::developer_private::EXTENSION_TYPE_EXTENSION:
-      result->type = api::developer_private::ITEM_TYPE_EXTENSION;
-      result->is_app = false;
+      result.type = api::developer_private::ITEM_TYPE_EXTENSION;
+      result.is_app = false;
       break;
     case api::developer_private::EXTENSION_TYPE_THEME:
-      result->type = api::developer_private::ITEM_TYPE_THEME;
-      result->is_app = false;
+      result.type = api::developer_private::ITEM_TYPE_THEME;
+      result.is_app = false;
       break;
     case api::developer_private::EXTENSION_TYPE_SHARED_MODULE:
       // Old api doesn't account for this.
       break;
     default:
       NOTREACHED();
   }
-  result->allow_file_access = info.file_access.is_active;
-  result->wants_file_access = info.file_access.is_enabled;
+  result.allow_file_access = info.file_access.is_active;
+  result.wants_file_access = info.file_access.is_enabled;
 
-  result->icon_url = info.icon_url;
+  result.icon_url = info.icon_url;
 
-  result->incognito_enabled = info.incognito_access.is_active;
-  result->allow_incognito = info.incognito_access.is_enabled;
+  result.incognito_enabled = info.incognito_access.is_active;
+  result.allow_incognito = info.incognito_access.is_enabled;
 
-  result->is_unpacked =
+  result.is_unpacked =
       info.location == api::developer_private::LOCATION_UNPACKED;
-  result->allow_reload = result->is_unpacked;
-  result->terminated =
+  result.allow_reload = result.is_unpacked;
+  result.terminated =
       info.state == api::developer_private::EXTENSION_STATE_TERMINATED;
 
   if (info.path)
-    result->path.reset(new std::string(*info.path));
+    result.path.reset(new std::string(*info.path));
   if (info.options_page)
-    result->options_url.reset(new std::string(info.options_page->url));
+    result.options_url.reset(new std::string(info.options_page->url));
   if (info.launch_url)
-    result->app_launch_url.reset(new std::string(*info.launch_url));
+    result.app_launch_url.reset(new std::string(*info.launch_url));
   if (!info.home_page.url.empty())
-    result->homepage_url.reset(new std::string(info.home_page.url));
-  result->update_url.reset(new std::string(info.update_url));
+    result.homepage_url.reset(new std::string(info.home_page.url));
+  result.update_url.reset(new std::string(info.update_url));
   for (const std::string& str_warning : info.install_warnings) {
-    scoped_ptr<api::developer_private::InstallWarning> warning(
-        new api::developer_private::InstallWarning());
-    warning->message = str_warning;
-    result->install_warnings.push_back(make_linked_ptr(warning.release()));
+    api::developer_private::InstallWarning warning;
+    warning.message = str_warning;
+    result.install_warnings.push_back(std::move(warning));
   }
-  for (const linked_ptr<api::developer_private::ManifestError>& error :
-           info.manifest_errors) {
-    CHECK(error.get());
-    scoped_ptr<base::DictionaryValue> value = error->ToValue();
+  for (const api::developer_private::ManifestError& error :
+       info.manifest_errors) {
+    scoped_ptr<base::DictionaryValue> value = error.ToValue();
     value->SetInteger("type", static_cast<int>(ExtensionError::MANIFEST_ERROR));
     value->SetInteger("level", static_cast<int>(logging::LOG_WARNING));
-    result->manifest_errors.push_back(make_linked_ptr(value.release()));
+    result.manifest_errors.push_back(make_linked_ptr(value.release()));
   }
-  for (const linked_ptr<api::developer_private::RuntimeError>& error :
-           info.runtime_errors) {
-    CHECK(error.get());
-    scoped_ptr<base::DictionaryValue> value = error->ToValue();
+  for (const api::developer_private::RuntimeError& error :
+       info.runtime_errors) {
+    scoped_ptr<base::DictionaryValue> value = error.ToValue();
     value->SetInteger("type", static_cast<int>(ExtensionError::RUNTIME_ERROR));
     logging::LogSeverity severity = logging::LOG_INFO;
-    if (error->severity == api::developer_private::ERROR_LEVEL_WARN)
+    if (error.severity == api::developer_private::ERROR_LEVEL_WARN)
       severity = logging::LOG_WARNING;
-    else if (error->severity == api::developer_private::ERROR_LEVEL_ERROR)
+    else if (error.severity == api::developer_private::ERROR_LEVEL_ERROR)
       severity = logging::LOG_ERROR;
     value->SetInteger("level", static_cast<int>(severity));
-    result->runtime_errors.push_back(make_linked_ptr(value.release()));
+    result.runtime_errors.push_back(make_linked_ptr(value.release()));
   }
-  result->offline_enabled = info.offline_enabled;
-  for (const linked_ptr<api::developer_private::ExtensionView>& view :
-           info.views) {
-    linked_ptr<api::developer_private::ItemInspectView> view_copy(
-        new api::developer_private::ItemInspectView());
-    GURL url(view->url);
+  result.offline_enabled = info.offline_enabled;
+  for (const api::developer_private::ExtensionView& view : info.views) {
+    api::developer_private::ItemInspectView view_copy;
+    GURL url(view.url);
     if (url.scheme() == kExtensionScheme) {
       // No leading slash.
-      view_copy->path = url.path().substr(1);
+      view_copy.path = url.path().substr(1);
     } else {
       // For live pages, use the full URL.
-      view_copy->path = url.spec();
+      view_copy.path = url.spec();
     }
-    view_copy->render_process_id = view->render_process_id;
-    view_copy->render_view_id = view->render_view_id;
-    view_copy->incognito = view->incognito;
-    view_copy->generated_background_page =
-        view_copy->path == kGeneratedBackgroundPageFilename;
-    result->views.push_back(view_copy);
+    view_copy.render_process_id = view.render_process_id;
+    view_copy.render_view_id = view.render_view_id;
+    view_copy.incognito = view.incognito;
+    view_copy.generated_background_page =
+        view_copy.path == kGeneratedBackgroundPageFilename;
+    result.views.push_back(std::move(view_copy));
   }
 
   return result;
 }
 
 }  // namespace developer_private_mangle
 }  // namespace extensions