Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/appcache/appcache_internals_ui.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 "content/browser/appcache/appcache_internals_ui.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 37 matching lines @@
   int64_t i = 0;
   base::StringToInt64(str.c_str(), &i);
   return i;
 }
 
 bool SortByResourceUrl(const AppCacheResourceInfo& lhs,
                        const AppCacheResourceInfo& rhs) {
   return lhs.url.spec() < rhs.url.spec();
 }
 
-scoped_ptr<base::DictionaryValue> GetDictionaryValueForResponseEnquiry(
+std::unique_ptr<base::DictionaryValue> GetDictionaryValueForResponseEnquiry(
     const content::AppCacheInternalsUI::Proxy::ResponseEnquiry&
         response_enquiry) {
-  scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict_value(
+      new base::DictionaryValue());
   dict_value->SetString("manifestURL", response_enquiry.manifest_url);
   dict_value->SetString("groupId",
                         base::Int64ToString(response_enquiry.group_id));
   dict_value->SetString("responseId",
                         base::Int64ToString(response_enquiry.response_id));
   return dict_value;
 }
 
-scoped_ptr<base::DictionaryValue> GetDictionaryValueForAppCacheInfo(
+std::unique_ptr<base::DictionaryValue> GetDictionaryValueForAppCacheInfo(
     const content::AppCacheInfo& appcache_info) {
-  scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict_value(
+      new base::DictionaryValue());
   dict_value->SetString("manifestURL", appcache_info.manifest_url.spec());
   dict_value->SetDouble("creationTime", appcache_info.creation_time.ToJsTime());
   dict_value->SetDouble("lastUpdateTime",
                         appcache_info.last_update_time.ToJsTime());
   dict_value->SetDouble("lastAccessTime",
                         appcache_info.last_access_time.ToJsTime());
   dict_value->SetString(
       "size",
       base::UTF16ToUTF8(base::FormatBytesUnlocalized(appcache_info.size)));
   dict_value->SetString("groupId", base::Int64ToString(appcache_info.group_id));
 
   return dict_value;
 }
 
-scoped_ptr<base::ListValue> GetListValueForAppCacheInfoVector(
+std::unique_ptr<base::ListValue> GetListValueForAppCacheInfoVector(
     const AppCacheInfoVector& appcache_info_vector) {
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (const AppCacheInfo& info : appcache_info_vector)
     list->Append(GetDictionaryValueForAppCacheInfo(info));
   return list;
 }
 
-scoped_ptr<base::ListValue> GetListValueFromAppCacheInfoCollection(
+std::unique_ptr<base::ListValue> GetListValueFromAppCacheInfoCollection(
     AppCacheInfoCollection* appcache_collection) {
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (const auto& key_value : appcache_collection->infos_by_origin) {
     base::DictionaryValue* dict = new base::DictionaryValue;
     dict->SetString("originURL", key_value.first.spec());
     dict->Set("manifests", GetListValueForAppCacheInfoVector(key_value.second));
-    list->Append(scoped_ptr<base::Value>(dict));
+    list->Append(std::unique_ptr<base::Value>(dict));
   }
   return list;
 }
 
-scoped_ptr<base::DictionaryValue> GetDictionaryValueForAppCacheResourceInfo(
+std::unique_ptr<base::DictionaryValue>
+GetDictionaryValueForAppCacheResourceInfo(
     const AppCacheResourceInfo& resource_info) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   dict->SetString("url", resource_info.url.spec());
   dict->SetString(
       "size",
       base::UTF16ToUTF8(base::FormatBytesUnlocalized(resource_info.size)));
   dict->SetString("responseId", base::Int64ToString(resource_info.response_id));
   dict->SetBoolean("isExplicit", resource_info.is_explicit);
   dict->SetBoolean("isManifest", resource_info.is_manifest);
   dict->SetBoolean("isMaster", resource_info.is_master);
   dict->SetBoolean("isFallback", resource_info.is_fallback);
   dict->SetBoolean("isIntercept", resource_info.is_intercept);
   dict->SetBoolean("isForeign", resource_info.is_foreign);
 
   return dict;
 }
 
-scoped_ptr<base::ListValue> GetListValueForAppCacheResourceInfoVector(
+std::unique_ptr<base::ListValue> GetListValueForAppCacheResourceInfoVector(
     AppCacheResourceInfoVector* resource_info_vector) {
-  scoped_ptr<base::ListValue> list(new base::ListValue);
+  std::unique_ptr<base::ListValue> list(new base::ListValue);
   for (const AppCacheResourceInfo& res_info : *resource_info_vector)
     list->Append(GetDictionaryValueForAppCacheResourceInfo(res_info));
   return list;
 }
 
 }  // namespace
 
 AppCacheInternalsUI::Proxy::Proxy(
     base::WeakPtr<AppCacheInternalsUI> appcache_internals_ui,
     const base::FilePath& partition_path)
@@ skipping 88 matching lines @@
         base::Bind(&Proxy::RequestAppCacheDetails, this, manifest_url));
     return;
   }
 
   if (appcache_service_)
     appcache_service_->storage()->LoadOrCreateGroup(GURL(manifest_url), this);
 }
 
 void AppCacheInternalsUI::Proxy::OnGroupLoaded(AppCacheGroup* appcache_group,
                                                const GURL& manifest_gurl) {
-  scoped_ptr<AppCacheResourceInfoVector> resource_info_vector;
+  std::unique_ptr<AppCacheResourceInfoVector> resource_info_vector;
   if (appcache_group && appcache_group->newest_complete_cache()) {
     resource_info_vector.reset(new AppCacheResourceInfoVector);
     appcache_group->newest_complete_cache()->ToResourceInfoVector(
         resource_info_vector.get());
     std::sort(resource_info_vector->begin(), resource_info_vector->end(),
               SortByResourceUrl);
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&AppCacheInternalsUI::OnAppCacheDetailsReady,
@@ skipping 33 matching lines @@
     return;
   ResponseEnquiry response_enquiry = response_enquiries_.front();
   response_enquiries_.pop_front();
   if (response) {
     scoped_refptr<AppCacheResponseInfo> response_info = response;
     const int64_t kLimit = 100 * 1000;
     int64_t amount_to_read =
         std::min(kLimit, response_info->response_data_size());
     scoped_refptr<net::IOBuffer> response_data(new net::IOBuffer(
         base::CheckedNumeric<size_t>(amount_to_read).ValueOrDie()));
-    scoped_ptr<AppCacheResponseReader> reader(
+    std::unique_ptr<AppCacheResponseReader> reader(
         appcache_service_->storage()->CreateResponseReader(
             GURL(response_enquiry.manifest_url), response_enquiry.group_id,
             response_enquiry.response_id));
 
     reader->ReadData(
         response_data.get(), amount_to_read,
         base::Bind(&Proxy::OnResponseDataReadComplete, this, response_enquiry,
                    response_info, base::Passed(&reader), response_data));
   } else {
     OnResponseDataReadComplete(response_enquiry, nullptr, nullptr, nullptr, -1);
   }
 }
 
 void AppCacheInternalsUI::Proxy::OnResponseDataReadComplete(
     const ResponseEnquiry& response_enquiry,
     scoped_refptr<AppCacheResponseInfo> response_info,
-    scoped_ptr<AppCacheResponseReader> reader,
+    std::unique_ptr<AppCacheResponseReader> reader,
     scoped_refptr<net::IOBuffer> response_data,
     int net_result_code) {
   if (shutdown_called_)
     return;
   if (!response_info || net_result_code < 0) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&AppCacheInternalsUI::OnFileDetailsFailed,
                    appcache_internals_ui_, response_enquiry, net_result_code));
   } else {
@@ skipping 112 matching lines @@
     bool deleted) {
   web_ui()->CallJavascriptFunction(
       kFunctionOnAppCacheInfoDeleted,
       base::StringValue(partition_path.AsUTF8Unsafe()),
       base::StringValue(manifest_url), base::FundamentalValue(deleted));
 }
 
 void AppCacheInternalsUI::OnAppCacheDetailsReady(
     const base::FilePath& partition_path,
     const std::string& manifest_url,
-    scoped_ptr<AppCacheResourceInfoVector> resource_info_vector) {
+    std::unique_ptr<AppCacheResourceInfoVector> resource_info_vector) {
   if (resource_info_vector) {
     web_ui()->CallJavascriptFunction(
         kFunctionOnAppCacheDetailsReady, base::StringValue(manifest_url),
         base::StringValue(partition_path.AsUTF8Unsafe()),
         *GetListValueForAppCacheResourceInfoVector(resource_info_vector.get()));
   } else {
     web_ui()->CallJavascriptFunction(
         kFunctionOnAppCacheDetailsReady, base::StringValue(manifest_url),
         base::StringValue(partition_path.AsUTF8Unsafe()));
   }
@@ skipping 50 matching lines @@
     const base::FilePath& partition_path) {
   for (const scoped_refptr<Proxy>& proxy : appcache_proxies_) {
     if (proxy->partition_path_ == partition_path)
       return proxy.get();
   }
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace content