Convert Pass()→std::move() for CrOS extension code.

extensions/browser/api/networking_config/networking_config_service.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 "extensions/browser/api/networking_config/networking_config_service.h"
+
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
-#include "extensions/browser/api/networking_config/networking_config_service.h"
 #include "extensions/common/api/networking_config.h"
 
 namespace extensions {
 
 namespace {
 
 bool IsValidNonEmptyHexString(const std::string& input) {
   size_t count = input.size();
   if (count == 0 || (count % 2) != 0)
     return false;
@@ skipping 17 matching lines @@
       guid(guid),
       authentication_state(authentication_state) {
 }
 
 NetworkingConfigService::NetworkingConfigService(
     content::BrowserContext* browser_context,
     scoped_ptr<EventDelegate> event_delegate,
     ExtensionRegistry* extension_registry)
     : browser_context_(browser_context),
       registry_observer_(this),
-      event_delegate_(event_delegate.Pass()),
+      event_delegate_(std::move(event_delegate)),
       weak_factory_(this) {
   registry_observer_.Add(extension_registry);
 }
 
 NetworkingConfigService::~NetworkingConfigService() {
 }
 
 void NetworkingConfigService::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
@@ skipping 83 matching lines @@
   if (onc_network_config.GetDictionaryWithoutPathExpansion(
           ::onc::network_config::kWiFi, &wifi_with_state) &&
       wifi_with_state->GetStringWithoutPathExpansion(::onc::wifi::kBSSID,
                                                      &bssid)) {
     event = CreatePortalDetectedEventAndDispatch(extension_id, guid, &bssid);
   } else {
     event = CreatePortalDetectedEventAndDispatch(extension_id, guid, nullptr);
   }
 
   EventRouter::Get(browser_context_)
-      ->DispatchEventToExtension(extension_id, event.Pass());
+      ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void NetworkingConfigService::OnGetPropertiesFailed(
     const std::string& extension_id,
     const std::string& guid,
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   LOG(WARNING) << "Failed to determine BSSID for network with guid " << guid
                << ": " << error_name;
   scoped_ptr<Event> event =
       CreatePortalDetectedEventAndDispatch(extension_id, guid, nullptr);
   EventRouter::Get(browser_context_)
-      ->DispatchEventToExtension(extension_id, event.Pass());
+      ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 scoped_ptr<Event> NetworkingConfigService::CreatePortalDetectedEventAndDispatch(
     const std::string& extension_id,
     const std::string& guid,
     const std::string* bssid) {
   const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
                                               ->network_state_handler()
                                               ->GetNetworkStateFromGuid(guid);
   if (!network)
     return nullptr;
 
   // Populate the NetworkInfo object.
   api::networking_config::NetworkInfo network_info;
   network_info.type = api::networking_config::NETWORK_TYPE_WIFI;
   const std::vector<uint8_t>& raw_ssid = network->raw_ssid();
   std::string hex_ssid = base::HexEncode(raw_ssid.data(), raw_ssid.size());
   network_info.hex_ssid = make_scoped_ptr(new std::string(hex_ssid));
   network_info.ssid = make_scoped_ptr(new std::string(network->name()));
   network_info.guid = make_scoped_ptr(new std::string(network->guid()));
   if (bssid)
     network_info.bssid.reset(new std::string(*bssid));
   scoped_ptr<base::ListValue> results =
       api::networking_config::OnCaptivePortalDetected::Create(network_info);
   scoped_ptr<Event> event(
       new Event(events::NETWORKING_CONFIG_ON_CAPTIVE_PORTAL_DETECTED,
                 api::networking_config::OnCaptivePortalDetected::kEventName,
-                results.Pass()));
-  return event.Pass();
+                std::move(results)));
+  return event;
 }
 
 void NetworkingConfigService::DispatchPortalDetectedEvent(
     const std::string& extension_id,
     const std::string& guid,
     const base::Closure& authentication_callback) {
   // This dispatch starts a new cycle of portal detection and authentication.
   // Ensure that any old |authentication_callback_| is dropped.
   authentication_callback_.Reset();
 
@@ skipping 10 matching lines @@
   network_handler->managed_network_configuration_handler()->GetProperties(
       "" /* empty userhash */, service_path,
       base::Bind(&NetworkingConfigService::OnGotProperties,
                  weak_factory_.GetWeakPtr(), extension_id, guid,
                  authentication_callback),
       base::Bind(&NetworkingConfigService::OnGetPropertiesFailed,
                  weak_factory_.GetWeakPtr(), extension_id, guid));
 }
 
 }  // namespace extensions