Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/web_resource/web_resource_service.cc

 // Copyright 2012 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/web_resource/web_resource_service.h"
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/prefs/pref_service.h"
 #include "net/base/load_flags.h"
@@ skipping 41 matching lines @@
   // If resource requests are not allowed, we'll get a callback when they are.
   if (resource_request_allowed_notifier_.ResourceRequestsAllowed())
     OnResourceRequestsAllowed();
 }
 
 WebResourceService::~WebResourceService() {
 }
 
 void WebResourceService::OnURLFetchComplete(const net::URLFetcher* source) {
   // Delete the URLFetcher when this function exits.
-  scoped_ptr<net::URLFetcher> clean_up_fetcher(url_fetcher_.release());
+  std::unique_ptr<net::URLFetcher> clean_up_fetcher(url_fetcher_.release());
 
   if (source->GetStatus().is_success() && source->GetResponseCode() == 200) {
     std::string data;
     source->GetResponseAsString(&data);
     // Calls EndFetch() on completion.
     // Full JSON parsing might spawn a utility process (for security).
     // To limit the the number of simultaneously active processes
     // (on Android in particular) we short-cut the full parsing in the case of
     // trivially "empty" JSONs.
     if (data.empty() || data == "{}") {
-      OnUnpackFinished(make_scoped_ptr(new base::DictionaryValue()));
+      OnUnpackFinished(base::WrapUnique(new base::DictionaryValue()));
     } else {
       parse_json_callback_.Run(data,
                                base::Bind(&WebResourceService::OnUnpackFinished,
                                           weak_ptr_factory_.GetWeakPtr()),
                                base::Bind(&WebResourceService::OnUnpackError,
                                           weak_ptr_factory_.GetWeakPtr()));
     }
   } else {
     // Don't parse data if attempt to download was unsuccessful.
     // Stop loading new web resource data, and silently exit.
@@ skipping 42 matching lines @@
                              net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SAVE_COOKIES);
   url_fetcher_->SetRequestContext(request_context_.get());
   url_fetcher_->Start();
 }
 
 void WebResourceService::EndFetch() {
   in_fetch_ = false;
 }
 
-void WebResourceService::OnUnpackFinished(scoped_ptr<base::Value> value) {
+void WebResourceService::OnUnpackFinished(std::unique_ptr<base::Value> value) {
   if (!value) {
     // Page information not properly read, or corrupted.
     OnUnpackError(kInvalidDataTypeError);
     return;
   }
   const base::DictionaryValue* dict = nullptr;
   if (!value->GetAsDictionary(&dict)) {
     OnUnpackError(kUnexpectedJSONFormatError);
     return;
   }
@@ skipping 25 matching lines @@
       // Wait at least |start_fetch_delay_ms_|.
       if (ms_until_update > start_fetch_delay_ms_)
         delay = ms_until_update;
     }
   }
   // Start fetch and wait for UpdateResourceCache.
   ScheduleFetch(delay);
 }
 
 }  // namespace web_resource