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

content/browser/appcache/appcache_request_handler.cc

 // Copyright (c) 2011 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_request_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "content/browser/appcache/appcache.h"
@@ skipping 60 matching lines @@
   }
 
   // Clear out our 'found' fields since we're starting a request for a
   // new resource, any values in those fields are no longer valid.
   found_entry_ = AppCacheEntry();
   found_fallback_entry_ = AppCacheEntry();
   found_cache_id_ = kAppCacheNoCacheId;
   found_manifest_url_ = GURL();
   found_network_namespace_ = false;
 
-  scoped_ptr<AppCacheURLRequestJob> job;
+  std::unique_ptr<AppCacheURLRequestJob> job;
   if (is_main_resource())
     job = MaybeLoadMainResource(request, network_delegate);
   else
     job = MaybeLoadSubResource(request, network_delegate);
 
   // If its been setup to deliver a network response, we can just delete
   // it now and return NULL instead to achieve that since it couldn't
   // have been started yet.
   if (job && job->is_delivering_network_response()) {
     DCHECK(!job->has_been_started());
@@ skipping 14 matching lines @@
     return NULL;
   // TODO(vabr) This is a temporary fix (see crbug/141114). We should get rid of
   // it once a more general solution to crbug/121325 is in place.
   if (!maybe_load_resource_executed_)
     return NULL;
   if (request->url().GetOrigin() == location.GetOrigin())
     return NULL;
 
   DCHECK(!job_.get());  // our jobs never generate redirects
 
-  scoped_ptr<AppCacheURLRequestJob> job;
+  std::unique_ptr<AppCacheURLRequestJob> job;
   if (found_fallback_entry_.has_response_id()) {
     // 6.9.6, step 4: If this results in a redirect to another origin,
     // get the resource of the fallback entry.
     job = CreateJob(request, network_delegate);
     DeliverAppCachedResponse(
         found_fallback_entry_, found_cache_id_, found_group_id_,
         found_manifest_url_,  true, found_namespace_entry_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
     job = CreateJob(request, network_delegate);
@@ skipping 36 matching lines @@
     const std::string kFallbackOverrideValue(
         "disallow-fallback");
     std::string header_value;
     request->GetResponseHeaderByName(kFallbackOverrideHeader, &header_value);
     if (header_value == kFallbackOverrideValue)
       return NULL;
   }
 
   // 6.9.6, step 4: If this results in a 4xx or 5xx status code
   // or there were network errors, get the resource of the fallback entry.
-  scoped_ptr<AppCacheURLRequestJob> job = CreateJob(request, network_delegate);
+  std::unique_ptr<AppCacheURLRequestJob> job =
+      CreateJob(request, network_delegate);
   DeliverAppCachedResponse(
       found_fallback_entry_, found_cache_id_, found_group_id_,
       found_manifest_url_, true, found_namespace_entry_url_);
   return job.release();
 }
 
 void AppCacheRequestHandler::GetExtraResponseInfo(int64_t* cache_id,
                                                   GURL* manifest_url) {
   *cache_id = cache_id_;
   *manifest_url = manifest_url_;
@@ skipping 86 matching lines @@
   manifest_url_ = GURL();
 
   cache_entry_not_found_ = job_->cache_entry_not_found();
   is_delivering_network_response_ = job_->is_delivering_network_response();
 
   storage()->CancelDelegateCallbacks(this);
 
   job_.reset();
 }
 
-scoped_ptr<AppCacheURLRequestJob> AppCacheRequestHandler::CreateJob(
+std::unique_ptr<AppCacheURLRequestJob> AppCacheRequestHandler::CreateJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
-  scoped_ptr<AppCacheURLRequestJob> job(new AppCacheURLRequestJob(
+  std::unique_ptr<AppCacheURLRequestJob> job(new AppCacheURLRequestJob(
       request, network_delegate, storage(), host_, is_main_resource(),
       base::Bind(&AppCacheRequestHandler::OnPrepareToRestart,
                  base::Unretained(this))));
   job_ = job->GetWeakPtr();
   return job;
 }
 
 // Main-resource handling ----------------------------------------------
 
-scoped_ptr<AppCacheURLRequestJob> AppCacheRequestHandler::MaybeLoadMainResource(
+std::unique_ptr<AppCacheURLRequestJob>
+AppCacheRequestHandler::MaybeLoadMainResource(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
   DCHECK(host_);
 
   // If a page falls into the scope of a ServiceWorker, any matching AppCaches
   // should be ignored. This depends on the ServiceWorker handler being invoked
   // prior to the AppCache handler.
   if (ServiceWorkerRequestHandler::IsControlledByServiceWorker(request)) {
     host_->enable_cache_selection(false);
     return nullptr;
   }
 
   host_->enable_cache_selection(true);
 
   const AppCacheHost* spawning_host =
       (resource_type_ == RESOURCE_TYPE_SHARED_WORKER) ?
       host_ : host_->GetSpawningHost();
   GURL preferred_manifest_url = spawning_host ?
       spawning_host->preferred_manifest_url() : GURL();
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
-  scoped_ptr<AppCacheURLRequestJob> job = CreateJob(request, network_delegate);
+  std::unique_ptr<AppCacheURLRequestJob> job =
+      CreateJob(request, network_delegate);
   storage()->FindResponseForMainRequest(
       request->url(), preferred_manifest_url, this);
   return job;
 }
 
 void AppCacheRequestHandler::OnMainResponseFound(
     const GURL& url,
     const AppCacheEntry& entry,
     const GURL& namespace_entry_url,
     const AppCacheEntry& fallback_entry,
@@ skipping 57 matching lines @@
     DeliverAppCachedResponse(
         found_entry_, found_cache_id_, found_group_id_, found_manifest_url_,
         false, found_namespace_entry_url_);
   } else {
     DeliverNetworkResponse();
   }
 }
 
 // Sub-resource handling ----------------------------------------------
 
-scoped_ptr<AppCacheURLRequestJob> AppCacheRequestHandler::MaybeLoadSubResource(
+std::unique_ptr<AppCacheURLRequestJob>
+AppCacheRequestHandler::MaybeLoadSubResource(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
 
   if (host_->is_selection_pending()) {
     // We have to wait until cache selection is complete and the
     // selected cache is loaded.
     is_waiting_for_cache_selection_ = true;
     return CreateJob(request, network_delegate);
   }
 
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete() ||
       host_->associated_cache()->owning_group()->is_being_deleted()) {
     return nullptr;
   }
 
-  scoped_ptr<AppCacheURLRequestJob> job = CreateJob(request, network_delegate);
+  std::unique_ptr<AppCacheURLRequestJob> job =
+      CreateJob(request, network_delegate);
   ContinueMaybeLoadSubResource();
   return job;
 }
 
 void AppCacheRequestHandler::ContinueMaybeLoadSubResource() {
   // 6.9.6 Changes to the networking model
   // If the resource is not to be fetched using the HTTP GET mechanism or
   // equivalent ... then fetch the resource normally.
   DCHECK(job_.get());
   DCHECK(host_->associated_cache() && host_->associated_cache()->is_complete());
@@ skipping 58 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace content