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

content/child/service_worker/service_worker_dispatcher.cc

 // Copyright 2013 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/child/service_worker/service_worker_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "content/child/child_thread.h"
@@ skipping 172 matching lines @@
   if (info.handle_id == kInvalidServiceWorkerHandleId)
     return NULL;
 
   WorkerObjectMap::iterator existing_worker =
       service_workers_.find(info.handle_id);
 
   if (existing_worker != service_workers_.end()) {
     if (adopt_handle) {
       // We are instructed to adopt a handle but we already have one, so
       // adopt and destroy a handle ref.
-      ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_);
+      ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
     }
     return existing_worker->second;
   }
 
   scoped_ptr<ServiceWorkerHandleReference> handle_ref =
       adopt_handle
-          ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_)
-          : ServiceWorkerHandleReference::Create(info, thread_safe_sender_);
+          ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get())
+          : ServiceWorkerHandleReference::Create(info,
+                                                 thread_safe_sender_.get());
   // WebServiceWorkerImpl constructor calls AddServiceWorker.
-  return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_);
+  return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_.get());
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::GetServiceWorkerRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     bool adopt_handle) {
   if (info.handle_id == kInvalidServiceWorkerRegistrationHandleId)
     return NULL;
 
   RegistrationObjectMap::iterator existing_registration =
       registrations_.find(info.handle_id);
 
   if (existing_registration != registrations_.end()) {
     if (adopt_handle) {
       // We are instructed to adopt a handle but we already have one, so
       // adopt and destroy a handle ref.
       ServiceWorkerRegistrationHandleReference::Adopt(
-          info, thread_safe_sender_);
+          info, thread_safe_sender_.get());
     }
     return existing_registration->second;
   }
 
   scoped_ptr<ServiceWorkerRegistrationHandleReference> handle_ref =
-      adopt_handle
-          ? ServiceWorkerRegistrationHandleReference::Adopt(
-              info, thread_safe_sender_)
-          : ServiceWorkerRegistrationHandleReference::Create(
-              info, thread_safe_sender_);
+      adopt_handle ? ServiceWorkerRegistrationHandleReference::Adopt(
+                         info, thread_safe_sender_.get())
+                   : ServiceWorkerRegistrationHandleReference::Create(
+                         info, thread_safe_sender_.get());
 
   // WebServiceWorkerRegistrationImpl constructor calls
   // AddServiceWorkerRegistration.
   return new WebServiceWorkerRegistrationImpl(handle_ref.Pass());
 }
 
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info) {
@@ skipping 225 matching lines @@
   registrations_[registration_handle_id] = registration;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorkerRegistration(
     int registration_handle_id) {
   DCHECK(ContainsKey(registrations_, registration_handle_id));
   registrations_.erase(registration_handle_id);
 }
 
 }  // namespace content