Remove implicit conversions from scoped_refptr to T* in content/browser/service_worker

content/browser/service_worker/service_worker_context_request_handler.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 "content/browser/service_worker/service_worker_context_request_handler.h"
 
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_read_from_cache_job.h"
 #include "content/browser/service_worker/service_worker_storage.h"
@@ skipping 16 matching lines @@
       version_(provider_host_->running_hosted_version()) {
   DCHECK(provider_host_->IsHostToRunningServiceWorker());
 }
 
 ServiceWorkerContextRequestHandler::~ServiceWorkerContextRequestHandler() {
 }
 
 net::URLRequestJob* ServiceWorkerContextRequestHandler::MaybeCreateJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
-  if (!provider_host_ || !version_ || !context_)
+  if (!provider_host_ || !version_.get() || !context_)
     return NULL;
 
   // We currently have no use case for hijacking a redirected request.
   if (request->url_chain().size() > 1)
     return NULL;
 
   // We only use the script cache for main script loading and
   // importScripts(), even if a cached script is xhr'd, we don't
   // retrieve it from the script cache.
   // TODO(michaeln): Get the desired behavior clarified in the spec,
@@ skipping 17 matching lines @@
     int extra_load_flags = 0;
     base::TimeDelta time_since_last_check =
         base::Time::Now() - registration->last_update_check();
     if (time_since_last_check > base::TimeDelta::FromHours(24))
       extra_load_flags = net::LOAD_BYPASS_CACHE;
 
     return new ServiceWorkerWriteToCacheJob(request,
                                             network_delegate,
                                             resource_type_,
                                             context_,
-                                            version_,
+                                            version_.get(),
                                             extra_load_flags,
                                             response_id);
   }
 
   int64 response_id = kInvalidServiceWorkerResponseId;
   if (ShouldReadFromScriptCache(request->url(), &response_id)) {
     return new ServiceWorkerReadFromCacheJob(
         request, network_delegate, context_, response_id);
   }
 
@@ skipping 23 matching lines @@
     const GURL& url, int64* response_id_out) {
   // We don't read from the script cache until the version is INSTALLED.
   if (version_->status() == ServiceWorkerVersion::NEW ||
       version_->status() == ServiceWorkerVersion::INSTALLING)
     return false;
   *response_id_out = version_->script_cache_map()->Lookup(url);
   return *response_id_out != kInvalidServiceWorkerResponseId;
 }
 
 }  // namespace content