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

chrome/browser/extensions/api/gcd_private/privet_v3_session.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/privet_v3_session.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
@@ skipping 68 matching lines @@
     return false;
 
   for (const base::Value* value : *list_of_string) {
     std::string string_value;
     if (value->GetAsString(&string_value) && string_value == expected_value)
       return true;
   }
   return false;
 }
 
-scoped_ptr<base::DictionaryValue> GetJson(const net::URLFetcher* source) {
+std::unique_ptr<base::DictionaryValue> GetJson(const net::URLFetcher* source) {
   if (!source->GetStatus().is_success())
     return nullptr;
 
   const net::HttpResponseHeaders* headers = source->GetResponseHeaders();
   if (!headers)
     return nullptr;
 
   std::string content_type;
   if (!headers->GetMimeType(&content_type))
     return nullptr;
@@ skipping 21 matching lines @@
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   net::URLFetcher* CreateURLFetcher(const GURL& url,
                                     net::URLFetcher::RequestType request_type,
                                     bool orphaned);
 
  private:
   void ReplyAndDestroyItself(Result result, const base::DictionaryValue& value);
   void OnTimeout();
 
-  scoped_ptr<net::URLFetcher> url_fetcher_;
+  std::unique_ptr<net::URLFetcher> url_fetcher_;
   base::WeakPtr<PrivetV3Session> session_;
   MessageCallback callback_;
 
   base::WeakPtrFactory<FetcherDelegate> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(FetcherDelegate);
 };
 
 PrivetV3Session::FetcherDelegate::FetcherDelegate(
     const base::WeakPtr<PrivetV3Session>& session,
     const PrivetV3Session::MessageCallback& callback)
     : session_(session),
       callback_(callback),
       weak_ptr_factory_(this) {}
 
 PrivetV3Session::FetcherDelegate::~FetcherDelegate() {}
 
 void PrivetV3Session::FetcherDelegate::OnURLFetchComplete(
     const net::URLFetcher* source) {
   VLOG(1) << "PrivetURLFetcher url: " << source->GetURL()
           << ", status: " << source->GetStatus().status()
           << ", error: " << source->GetStatus().error()
           << ", response code: " << source->GetResponseCode();
 
-  scoped_ptr<base::DictionaryValue> value = GetJson(source);
+  std::unique_ptr<base::DictionaryValue> value = GetJson(source);
   if (!value) {
     return ReplyAndDestroyItself(Result::STATUS_CONNECTIONERROR,
                                  base::DictionaryValue());
   }
 
   bool has_error = value->HasKey(kPrivetV3KeyError);
   LOG_IF(ERROR, has_error) << "Response: " << value.get();
   ReplyAndDestroyItself(
       has_error ? Result::STATUS_DEVICEERROR : Result::STATUS_SUCCESS, *value);
 }
@@ skipping 341 matching lines @@
   // Only session with pairing in process needs to be canceled. Paired sessions
   // (in https mode) does not need to be canceled.
   if (session_id_.empty() || use_https_)
     return;
   base::DictionaryValue input;
   input.SetString(kPrivetV3KeySessionId, session_id_);
   StartPostRequest(kPrivetV3PairingCancelPath, input, MessageCallback());
 }
 
 }  // namespace extensions