Convert Pass()→std::move() in //chrome

chrome/common/extensions/manifest_handlers/automation.cc

 // Copyright 2014 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/common/extensions/manifest_handlers/automation.h"
 
+#include <utility>
+
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/extensions/api/manifest_types.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/api_permission_set.h"
 #include "extensions/common/permissions/manifest_permission.h"
 #include "extensions/common/permissions/permission_message_util.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ skipping 16 matching lines @@
 }
 
 namespace errors = manifest_errors;
 namespace keys = extensions::manifest_keys;
 using api::manifest_types::Automation;
 
 class AutomationManifestPermission : public ManifestPermission {
  public:
   explicit AutomationManifestPermission(
       scoped_ptr<const AutomationInfo> automation_info)
-      : automation_info_(automation_info.Pass()) {}
+      : automation_info_(std::move(automation_info)) {}
 
   // extensions::ManifestPermission overrides.
   std::string name() const override;
 
   std::string id() const override;
 
   PermissionIDSet GetPermissions() const override;
 
   bool FromValue(const base::Value* value) override;
 
@@ skipping 47 matching lines @@
 
 bool AutomationManifestPermission::FromValue(const base::Value* value) {
   base::string16 error;
   automation_info_.reset(AutomationInfo::FromValue(*value,
                                                    NULL /* install_warnings */,
                                                    &error).release());
   return error.empty();
 }
 
 scoped_ptr<base::Value> AutomationManifestPermission::ToValue() const {
-  return AutomationInfo::ToValue(*automation_info_).Pass();
+  return AutomationInfo::ToValue(*automation_info_);
 }
 
 ManifestPermission* AutomationManifestPermission::Diff(
     const ManifestPermission* rhs) const {
   const AutomationManifestPermission* other =
       static_cast<const AutomationManifestPermission*>(rhs);
 
   bool desktop = automation_info_->desktop && !other->automation_info_->desktop;
   bool interact =
       automation_info_->interact && !other->automation_info_->interact;
@@ skipping 147 matching lines @@
   if (specified_matches && matches.is_empty()) {
     install_warnings->push_back(
         InstallWarning(automation_errors::kErrorNoMatchesProvided));
   }
 
   return make_scoped_ptr(new AutomationInfo(desktop, matches, interact));
 }
 
 // static
 scoped_ptr<base::Value> AutomationInfo::ToValue(const AutomationInfo& info) {
-  return AsManifestType(info)->ToValue().Pass();
+  return AsManifestType(info)->ToValue();
 }
 
 // static
 scoped_ptr<Automation> AutomationInfo::AsManifestType(
     const AutomationInfo& info) {
   scoped_ptr<Automation> automation(new Automation);
   if (!info.desktop && !info.interact && info.matches.size() == 0) {
     automation->as_boolean.reset(new bool(true));
-    return automation.Pass();
+    return automation;
   }
 
   Automation::Object* as_object = new Automation::Object;
   as_object->desktop.reset(new bool(info.desktop));
   as_object->interact.reset(new bool(info.interact));
   if (info.matches.size() > 0) {
     as_object->matches.reset(info.matches.ToStringVector().release());
   }
   automation->as_object.reset(as_object);
-  return automation.Pass();
+  return automation;
 }
 
 AutomationInfo::AutomationInfo() : desktop(false), interact(false) {
 }
 
 AutomationInfo::AutomationInfo(bool desktop,
                                const URLPatternSet matches,
                                bool interact)
     : desktop(desktop), matches(matches), interact(interact) {
 }
 
 AutomationInfo::~AutomationInfo() {
 }
 
 }  // namespace extensions