Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/custom_handlers/protocol_handler_registry.cc

 // Copyright (c) 2012 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 "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 145 matching lines @@
 
 // JobInterceptorFactory -------------------------------------------------------
 
 // Instances of JobInterceptorFactory are produced for ownership by the IO
 // thread where it handler URL requests. We should never hold
 // any pointers on this class, only produce them in response to
 // requests via |ProtocolHandlerRegistry::CreateJobInterceptorFactory|.
 ProtocolHandlerRegistry::JobInterceptorFactory::JobInterceptorFactory(
     IOThreadDelegate* io_thread_delegate)
     : io_thread_delegate_(io_thread_delegate) {
-  DCHECK(io_thread_delegate_);
+  DCHECK(io_thread_delegate_.get());
   DetachFromThread();
 }
 
 ProtocolHandlerRegistry::JobInterceptorFactory::~JobInterceptorFactory() {
 }
 
 void ProtocolHandlerRegistry::JobInterceptorFactory::Chain(
     scoped_ptr<net::URLRequestJobFactory> job_factory) {
   job_factory_ = job_factory.Pass();
 }
@@ skipping 117 matching lines @@
 }
 
 void ProtocolHandlerRegistry::Delegate::RegisterWithOSAsDefaultClient(
     const std::string& protocol, ProtocolHandlerRegistry* registry) {
   DefaultClientObserver* observer = CreateShellObserver(registry);
   // The worker pointer is reference counted. While it is running the
   // message loops of the FILE and UI thread will hold references to it
   // and it will be automatically freed once all its tasks have finished.
   scoped_refptr<ShellIntegration::DefaultProtocolClientWorker> worker;
   worker = CreateShellWorker(observer, protocol);
-  observer->SetWorker(worker);
+  observer->SetWorker(worker.get());
   registry->default_client_observers_.push_back(observer);
   worker->StartSetAsDefault();
 }
 
 // ProtocolHandlerRegistry -----------------------------------------------------
 
 ProtocolHandlerRegistry::ProtocolHandlerRegistry(Profile* profile,
     Delegate* delegate)
     : profile_(profile),
       delegate_(delegate),
@@ skipping 152 matching lines @@
 
   // For each default protocol handler, check that we are still registered
   // with the OS as the default application.
   if (ShouldRemoveHandlersNotInOS()) {
     for (ProtocolHandlerMap::const_iterator p = default_handlers_.begin();
          p != default_handlers_.end(); ++p) {
       ProtocolHandler handler = p->second;
       DefaultClientObserver* observer = delegate_->CreateShellObserver(this);
       scoped_refptr<ShellIntegration::DefaultProtocolClientWorker> worker;
       worker = delegate_->CreateShellWorker(observer, handler.protocol());
-      observer->SetWorker(worker);
+      observer->SetWorker(worker.get());
       default_client_observers_.push_back(observer);
       worker->StartCheckIsDefault();
     }
   }
 }
 
 int ProtocolHandlerRegistry::GetHandlerIndex(const std::string& scheme) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const ProtocolHandler& handler = GetHandlerFor(scheme);
   if (handler.IsEmpty())
@@ skipping 387 matching lines @@
   RegisterProtocolHandler(handler);
   SetDefault(handler);
 }
 
 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // this is always created on the UI thread (in profile_io's
   // InitializeOnUIThread. Any method calls must be done
   // on the IO thread (this is checked).
-  return scoped_ptr<JobInterceptorFactory>(new JobInterceptorFactory(
-      io_thread_delegate_));
+  return scoped_ptr<JobInterceptorFactory>(
+      new JobInterceptorFactory(io_thread_delegate_.get()));
 }