Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/gcd_private/gcd_private_api.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/browser/extensions/api/gcd_private/gcd_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 55 matching lines @@
                    const SessionCallback& callback);
 
   void SendMessage(int session_id,
                    const std::string& api,
                    const base::DictionaryValue& input,
                    const MessageResponseCallback& callback);
 
   void RemoveSession(int session_id);
   void RemoveSessionDelayed(int session_id);
 
-  scoped_ptr<base::ListValue> GetPrefetchedSSIDList();
+  std::unique_ptr<base::ListValue> GetPrefetchedSSIDList();
 
  private:
   typedef std::map<std::string /* ssid */, std::string /* password */>
       PasswordMap;
 
   void SendMessageInternal(int session_id,
                            const std::string& api,
                            const base::DictionaryValue& input,
                            const MessageResponseCallback& callback);
 
@@ skipping 85 matching lines @@
     return callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR);
 
   found->second.session->ConfirmCode(code, callback);
 }
 
 void GcdPrivateAPIImpl::SendMessage(int session_id,
                                     const std::string& api,
                                     const base::DictionaryValue& input,
                                     const MessageResponseCallback& callback) {
   const base::DictionaryValue* input_actual = &input;
-  scoped_ptr<base::DictionaryValue> input_cloned;
+  std::unique_ptr<base::DictionaryValue> input_cloned;
 
   if (api == kPrivatAPISetup) {
     const base::DictionaryValue* wifi = NULL;
 
     if (input.GetDictionary(kPrivetKeyWifi, &wifi)) {
       std::string ssid;
 
       if (!wifi->GetString(kPrivetKeySSID, &ssid)) {
         LOG(ERROR) << "Missing " << kPrivetKeySSID;
         return callback.Run(gcd_private::STATUS_SETUPPARSEERROR,
@@ skipping 21 matching lines @@
 void GcdPrivateAPIImpl::RemoveSession(int session_id) {
   sessions_.erase(session_id);
 }
 
 void GcdPrivateAPIImpl::RemoveSessionDelayed(int session_id) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&GcdPrivateAPIImpl::RemoveSession,
                             weak_ptr_factory_.GetWeakPtr(), session_id));
 }
 
-scoped_ptr<base::ListValue> GcdPrivateAPIImpl::GetPrefetchedSSIDList() {
-  scoped_ptr<base::ListValue> retval(new base::ListValue);
+std::unique_ptr<base::ListValue> GcdPrivateAPIImpl::GetPrefetchedSSIDList() {
+  std::unique_ptr<base::ListValue> retval(new base::ListValue);
 
   return retval;
 }
 
 
 
 GcdPrivateAPI::GcdPrivateAPI(content::BrowserContext* context)
     : impl_(new GcdPrivateAPIImpl(context)) {
 }
 
 GcdPrivateAPI::~GcdPrivateAPI() {
 }
 
 // static
 BrowserContextKeyedAPIFactory<GcdPrivateAPI>*
 GcdPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 GcdPrivateGetDeviceInfoFunction::GcdPrivateGetDeviceInfoFunction() {
 }
 
 GcdPrivateGetDeviceInfoFunction::~GcdPrivateGetDeviceInfoFunction() {
 }
 
 bool GcdPrivateGetDeviceInfoFunction::RunAsync() {
-  scoped_ptr<gcd_private::CreateSession::Params> params =
+  std::unique_ptr<gcd_private::CreateSession::Params> params =
       gcd_private::CreateSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
   GcdPrivateAPIImpl::CreateSessionCallback callback =
       base::Bind(&GcdPrivateGetDeviceInfoFunction::OnSessionInitialized, this);
   gcd_api->CreateSession(params->service_name, callback);
@@ skipping 15 matching lines @@
   gcd_api->RemoveSessionDelayed(session_id);
 }
 
 GcdPrivateCreateSessionFunction::GcdPrivateCreateSessionFunction() {
 }
 
 GcdPrivateCreateSessionFunction::~GcdPrivateCreateSessionFunction() {
 }
 
 bool GcdPrivateCreateSessionFunction::RunAsync() {
-  scoped_ptr<gcd_private::CreateSession::Params> params =
+  std::unique_ptr<gcd_private::CreateSession::Params> params =
       gcd_private::CreateSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
   GcdPrivateAPIImpl::CreateSessionCallback callback =
       base::Bind(&GcdPrivateCreateSessionFunction::OnSessionInitialized, this);
   gcd_api->CreateSession(params->service_name, callback);
@@ skipping 30 matching lines @@
   SendResponse(true);
 }
 
 GcdPrivateStartPairingFunction::GcdPrivateStartPairingFunction() {
 }
 
 GcdPrivateStartPairingFunction::~GcdPrivateStartPairingFunction() {
 }
 
 bool GcdPrivateStartPairingFunction::RunAsync() {
-  scoped_ptr<gcd_private::StartPairing::Params> params =
+  std::unique_ptr<gcd_private::StartPairing::Params> params =
       gcd_private::StartPairing::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
   gcd_api->StartPairing(
       params->session_id, params->pairing_type,
       base::Bind(&GcdPrivateStartPairingFunction::OnPairingStarted, this));
 
   return true;
 }
 
 void GcdPrivateStartPairingFunction::OnPairingStarted(
     api::gcd_private::Status status) {
   results_ = gcd_private::StartPairing::Results::Create(status);
   SendResponse(true);
 }
 
 GcdPrivateConfirmCodeFunction::GcdPrivateConfirmCodeFunction() {
 }
 
 GcdPrivateConfirmCodeFunction::~GcdPrivateConfirmCodeFunction() {
 }
 
 bool GcdPrivateConfirmCodeFunction::RunAsync() {
-  scoped_ptr<gcd_private::ConfirmCode::Params> params =
+  std::unique_ptr<gcd_private::ConfirmCode::Params> params =
       gcd_private::ConfirmCode::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
   gcd_api->ConfirmCode(
       params->session_id, params->code,
       base::Bind(&GcdPrivateConfirmCodeFunction::OnCodeConfirmed, this));
 
   return true;
 }
 
 void GcdPrivateConfirmCodeFunction::OnCodeConfirmed(
     api::gcd_private::Status status) {
   results_ = gcd_private::ConfirmCode::Results::Create(status);
   SendResponse(true);
 }
 
 GcdPrivateSendMessageFunction::GcdPrivateSendMessageFunction() {
 }
 
 GcdPrivateSendMessageFunction::~GcdPrivateSendMessageFunction() {
 }
 
 bool GcdPrivateSendMessageFunction::RunAsync() {
-  scoped_ptr<gcd_private::PassMessage::Params> params =
+  std::unique_ptr<gcd_private::PassMessage::Params> params =
       gcd_private::PassMessage::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
 
   gcd_api->SendMessage(
       params->session_id,
@@ skipping 14 matching lines @@
   SendResponse(true);
 }
 
 GcdPrivateTerminateSessionFunction::GcdPrivateTerminateSessionFunction() {
 }
 
 GcdPrivateTerminateSessionFunction::~GcdPrivateTerminateSessionFunction() {
 }
 
 bool GcdPrivateTerminateSessionFunction::RunAsync() {
-  scoped_ptr<gcd_private::TerminateSession::Params> params =
+  std::unique_ptr<gcd_private::TerminateSession::Params> params =
       gcd_private::TerminateSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
   gcd_api->RemoveSession(params->session_id);
 
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions