Cleanup usage of scoped_ptr<> in remoting for C++11

remoting/host/setup/me2me_native_messaging_host.cc

 // Copyright 2013 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 "remoting/host/setup/me2me_native_messaging_host.h"
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 99 matching lines @@
 
   // If the client supplies an ID, it will expect it in the response. This
   // might be a string or a number, so cope with both.
   const base::Value* id;
   if (message_dict->Get("id", &id))
     response->Set("id", id->DeepCopy());
 
   std::string type;
   if (!message_dict->GetString("type", &type)) {
     LOG(ERROR) << "'type' not found";
-    channel_->SendMessage(scoped_ptr<base::Value>());
+    channel_->SendMessage(nullptr);
     return;
   }
 
   response->SetString("type", type + "Response");
 
   if (type == "hello") {
     ProcessHello(message_dict.Pass(), response.Pass());
   } else if (type == "clearPairedClients") {
     ProcessClearPairedClients(message_dict.Pass(), response.Pass());
   } else if (type == "deletePairedClient") {
@@ skipping 36 matching lines @@
 void Me2MeNativeMessagingHost::ProcessHello(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetString("version", STRINGIZE(VERSION));
   scoped_ptr<base::ListValue> supported_features_list(new base::ListValue());
   supported_features_list->AppendStrings(std::vector<std::string>(
       kSupportedFeatures, kSupportedFeatures + arraysize(kSupportedFeatures)));
   response->Set("supportedFeatures", supported_features_list.release());
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessClearPairedClients(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (needs_elevation_) {
     if (!DelegateToElevatedHost(message.Pass()))
       SendBooleanResult(response.Pass(), false);
@@ skipping 37 matching lines @@
     SendBooleanResult(response.Pass(), false);
   }
 }
 
 void Me2MeNativeMessagingHost::ProcessGetHostName(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetString("hostname", net::GetHostName());
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGetPinHash(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string host_id;
   if (!message->GetString("hostId", &host_id)) {
     LOG(ERROR) << "'hostId' not found: " << message;
     OnError();
     return;
   }
   std::string pin;
   if (!message->GetString("pin", &pin)) {
     LOG(ERROR) << "'pin' not found: " << message;
     OnError();
     return;
   }
   response->SetString("hash", MakeHostPinHash(host_id, pin));
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGenerateKeyPair(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::Generate();
   response->SetString("privateKey", key_pair->ToString());
   response->SetString("publicKey", key_pair->GetPublicKey());
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessUpdateDaemonConfig(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(message.Pass());
   if (!config_dict) {
@@ skipping 102 matching lines @@
     case DaemonController::STATE_STARTED:
       response->SetString("state", "STARTED");
       break;
     case DaemonController::STATE_STOPPING:
       response->SetString("state", "STOPPING");
       break;
     case DaemonController::STATE_UNKNOWN:
       response->SetString("state", "UNKNOWN");
       break;
   }
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGetHostClientId(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetString("clientId", google_apis::GetOAuth2ClientID(
       google_apis::CLIENT_REMOTING_HOST));
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessGetCredentialsFromAuthCode(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string auth_code;
   if (!message->GetString("authorizationCode", &auth_code)) {
     LOG(ERROR) << "'authorizationCode' string not found.";
@@ skipping 16 matching lines @@
 void Me2MeNativeMessagingHost::SendConfigResponse(
     scoped_ptr<base::DictionaryValue> response,
     scoped_ptr<base::DictionaryValue> config) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (config) {
     response->Set("config", config.release());
   } else {
     response->Set("config", base::Value::CreateNullValue());
   }
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendPairedClientsResponse(
     scoped_ptr<base::DictionaryValue> response,
     scoped_ptr<base::ListValue> pairings) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->Set("pairedClients", pairings.release());
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendUsageStatsConsentResponse(
     scoped_ptr<base::DictionaryValue> response,
     const DaemonController::UsageStatsConsent& consent) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetBoolean("supported", consent.supported);
   response->SetBoolean("allowed", consent.allowed);
   response->SetBoolean("setByPolicy", consent.set_by_policy);
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendAsyncResult(
     scoped_ptr<base::DictionaryValue> response,
     DaemonController::AsyncResult result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (result) {
     case DaemonController::RESULT_OK:
       response->SetString("result", "OK");
       break;
     case DaemonController::RESULT_FAILED:
       response->SetString("result", "FAILED");
       break;
     case DaemonController::RESULT_CANCELLED:
       response->SetString("result", "CANCELLED");
       break;
     case DaemonController::RESULT_FAILED_DIRECTORY:
       response->SetString("result", "FAILED_DIRECTORY");
       break;
   }
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendBooleanResult(
     scoped_ptr<base::DictionaryValue> response, bool result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetBoolean("result", result);
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::SendCredentialsResponse(
     scoped_ptr<base::DictionaryValue> response,
     const std::string& user_email,
     const std::string& refresh_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   response->SetString("userEmail", user_email);
   response->SetString("refreshToken", refresh_token);
-  channel_->SendMessage(response.PassAs<base::Value>());
+  channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::OnError() {
   // Trigger a host shutdown by sending a NULL message.
-  channel_->SendMessage(scoped_ptr<base::Value>());
+  channel_->SendMessage(nullptr);
 }
 
 void Me2MeNativeMessagingHost::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!quit_closure_.is_null())
     base::ResetAndReturn(&quit_closure_).Run();
 }
 
 #if defined(OS_WIN)
@@ skipping 15 matching lines @@
 }
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     scoped_ptr<base::DictionaryValue> message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   EnsureElevatedHostCreated();
 
   // elevated_channel_ will be null if user rejects the UAC request.
   if (elevated_channel_)
-    elevated_channel_->SendMessage(message.PassAs<base::Value>());
+    elevated_channel_->SendMessage(message.Pass());
 
   return elevated_channel_ != NULL;
 }
 
 void Me2MeNativeMessagingHost::EnsureElevatedHostCreated() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(needs_elevation_);
 
   if (elevated_channel_)
     return;
@@ skipping 155 matching lines @@
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     scoped_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting