Service worker fixups for scoped_refptr operator T* removal.

content/browser/service_worker/service_worker_cache_storage_manager.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_cache_storage_manager.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 }
 
 }  // namespace
 
 namespace content {
 
 // static
 scoped_ptr<ServiceWorkerCacheStorageManager>
 ServiceWorkerCacheStorageManager::Create(
     const base::FilePath& path,
-    base::SequencedTaskRunner* cache_task_runner) {
+    const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner) {
   base::FilePath root_path = path;
   if (!path.empty()) {
     root_path = path.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
                     .AppendASCII("CacheStorage");
   }
 
   return make_scoped_ptr(
       new ServiceWorkerCacheStorageManager(root_path, cache_task_runner));
 }
 
@@ skipping 82 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache_storage_map_.empty());
   DCHECK(!request_context_ || request_context_ == request_context);
   DCHECK(!blob_context_ || blob_context_.get() == blob_storage_context.get());
   request_context_ = request_context;
   blob_context_ = blob_storage_context;
 }
 
 ServiceWorkerCacheStorageManager::ServiceWorkerCacheStorageManager(
     const base::FilePath& path,
-    base::SequencedTaskRunner* cache_task_runner)
+    const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner)
     : root_path_(path),
       cache_task_runner_(cache_task_runner),
       request_context_(NULL) {
 }
 
 ServiceWorkerCacheStorage*
 ServiceWorkerCacheStorageManager::FindOrCreateServiceWorkerCacheManager(
     const GURL& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(request_context_);
 
   ServiceWorkerCacheStorageMap::const_iterator it =
       cache_storage_map_.find(origin);
   if (it == cache_storage_map_.end()) {
     bool memory_only = root_path_.empty();
     ServiceWorkerCacheStorage* cache_storage =
         new ServiceWorkerCacheStorage(ConstructOriginPath(root_path_, origin),
                                       memory_only,
                                       cache_task_runner_.get(),
                                       request_context_,
                                       blob_context_);
     // The map owns fetch_stores.
     cache_storage_map_.insert(std::make_pair(origin, cache_storage));
     return cache_storage;
   }
   return it->second;
 }
 
 }  // namespace content