Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/certificate_transparency/log_proof_fetcher.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 "components/certificate_transparency/log_proof_fetcher.h"
 
 #include <iterator>
+#include <memory>
 
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "components/safe_json/safe_json_parser.h"
@@ skipping 46 matching lines @@
   void StartNextReadLoop();
 
   // Invokes the success callback. After this method is called, the LogFetcher
   // is deleted and no longer safe to call.
   void RequestComplete();
 
   // Invokes the failure callback with the supplied error information.
   // After this method the LogFetcher is deleted and no longer safe to call.
   void InvokeFailureCallback(int net_error, int http_response_code);
 
-  scoped_ptr<net::URLRequest> url_request_;
+  std::unique_ptr<net::URLRequest> url_request_;
   const GURL request_url_;
   base::Closure success_callback_;
   FailureCallback failure_callback_;
   scoped_refptr<net::IOBufferWithSize> response_buffer_;
   std::string assembled_response_;
 
   DISALLOW_COPY_AND_ASSIGN(LogFetcher);
 };
 
 LogFetcher::LogFetcher(net::URLRequestContext* request_context,
@@ skipping 143 matching lines @@
   // handing the parsed JSON to HandleParsedJson, which is request-specific).
   void HandleFetchCompletion();
 
   // Handle network failure to complete the request to the log, by invoking
   // the |done_callback_|.
   virtual void HandleNetFailure(int net_error, int http_response_code);
 
  protected:
   // Handle successful parsing of JSON by invoking HandleParsedJson, then
   // invoking the |done_callback_| with the returned Closure.
-  void OnJsonParseSuccess(scoped_ptr<base::Value> parsed_json);
+  void OnJsonParseSuccess(std::unique_ptr<base::Value> parsed_json);
 
   // Handle failure to parse the JSON by invoking HandleJsonParseFailure, then
   // invoking the |done_callback_| with the returned Closure.
   void OnJsonParseError(const std::string& error);
 
   // Handle respones JSON that parsed successfully, usually by
   // returning the success callback bound to parsed values as a Closure.
   virtual base::Closure HandleParsedJson(const base::Value& parsed_json) = 0;
 
   // Handle failure to parse response JSON, usually by returning the failure
   // callback bound to a request-specific net error code.
   virtual base::Closure HandleJsonParseFailure(
       const std::string& json_error) = 0;
 
   const std::string log_id_;
   LogProofFetcher::FetchFailedCallback failure_callback_;
-  scoped_ptr<LogFetcher> fetcher_;
+  std::unique_ptr<LogFetcher> fetcher_;
   DoneCallback done_callback_;
 
   base::WeakPtrFactory<LogResponseHandler> weak_factory_;
 };
 
 LogResponseHandler::LogResponseHandler(
     const std::string& log_id,
     const LogProofFetcher::FetchFailedCallback& failure_callback)
     : log_id_(log_id),
       failure_callback_(failure_callback),
@@ skipping 35 matching lines @@
   LogProofFetcher::FetchFailedCallback failure_callback =
       base::ResetAndReturn(&failure_callback_);
 
   base::ResetAndReturn(&done_callback_)
       .Run(
           base::Bind(failure_callback, log_id_, net_error, http_response_code));
   // NOTE: |this| is not valid after the |done_callback_| is invoked.
 }
 
 void LogResponseHandler::OnJsonParseSuccess(
-    scoped_ptr<base::Value> parsed_json) {
+    std::unique_ptr<base::Value> parsed_json) {
   base::ResetAndReturn(&done_callback_).Run(HandleParsedJson(*parsed_json));
   // NOTE: |this| is not valid after the |done_callback_| is invoked.
 }
 
 void LogResponseHandler::OnJsonParseError(const std::string& error) {
   base::ResetAndReturn(&done_callback_).Run(HandleJsonParseFailure(error));
   // NOTE: |this| is not valid after the |done_callback_| is invoked.
 }
 
 class GetSTHLogResponseHandler : public LogResponseHandler {
@@ skipping 114 matching lines @@
                                   const base::Closure& requestor_callback) {
   auto it = inflight_fetches_.find(log_handler);
   DCHECK(it != inflight_fetches_.end());
 
   delete *it;
   inflight_fetches_.erase(it);
   requestor_callback.Run();
 }
 
 }  // namespace certificate_transparency