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

content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 355 matching lines @@
   db_message_filter_ = new DBMessageFilter();
   AddFilter(db_message_filter_.get());
 
 #if defined(ENABLE_WEBRTC)
   webrtc::SetupEventTracer(&GetCategoryGroupEnabled, &AddTraceEvent);
 
   peer_connection_tracker_.reset(new PeerConnectionTracker());
   AddObserver(peer_connection_tracker_.get());
 
   p2p_socket_dispatcher_ = new P2PSocketDispatcher(GetIOMessageLoopProxy());
-  AddFilter(p2p_socket_dispatcher_);
+  AddFilter(p2p_socket_dispatcher_.get());
 #endif  // defined(ENABLE_WEBRTC)
   vc_manager_ = new VideoCaptureImplManager();
   AddFilter(vc_manager_->video_capture_message_filter());
 
   audio_input_message_filter_ =
       new AudioInputMessageFilter(GetIOMessageLoopProxy());
   AddFilter(audio_input_message_filter_.get());
 
   audio_message_filter_ = new AudioMessageFilter(GetIOMessageLoopProxy());
   AddFilter(audio_message_filter_.get());
@@ skipping 33 matching lines @@
 
 void RenderThreadImpl::Shutdown() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 
   // Wait for all databases to be closed.
   if (web_database_observer_impl_)
     web_database_observer_impl_->WaitForAllDatabasesToClose();
 
   // Shutdown in reverse of the initialization order.
-  if (devtools_agent_message_filter_) {
+  if (devtools_agent_message_filter_.get()) {
     RemoveFilter(devtools_agent_message_filter_.get());
     devtools_agent_message_filter_ = NULL;
   }
 
   RemoveFilter(audio_input_message_filter_.get());
   audio_input_message_filter_ = NULL;
 
   RemoveFilter(audio_message_filter_.get());
   audio_message_filter_ = NULL;
 
   RemoveFilter(vc_manager_->video_capture_message_filter());
 
   RemoveFilter(db_message_filter_.get());
   db_message_filter_ = NULL;
 
   // Shutdown the file thread if it's running.
   if (file_thread_)
     file_thread_->Stop();
 
-  if (compositor_output_surface_filter_) {
+  if (compositor_output_surface_filter_.get()) {
     RemoveFilter(compositor_output_surface_filter_.get());
     compositor_output_surface_filter_ = NULL;
   }
 
   compositor_thread_.reset();
   if (input_handler_manager_) {
     RemoveFilter(input_handler_manager_->GetMessageFilter());
     input_handler_manager_.reset();
   }
 
   if (webkit_platform_support_)
     WebKit::shutdown();
 
   lazy_tls.Pointer()->Set(NULL);
 
   // TODO(port)
 #if defined(OS_WIN)
   // Clean up plugin channels before this thread goes away.
   NPChannelBase::CleanupChannels();
 #endif
 
   // Leak shared contexts on other threads, as we can not get to the correct
   // thread to destroy them.
-  if (shared_contexts_compositor_thread_)
+  if (shared_contexts_compositor_thread_.get())
     shared_contexts_compositor_thread_->set_leak_on_destroy();
 }
 
 bool RenderThreadImpl::Send(IPC::Message* msg) {
   // Certain synchronous messages cannot always be processed synchronously by
   // the browser, e.g., Chrome frame communicating with the embedding browser.
   // This could cause a complete hang of Chrome if a windowed plug-in is trying
   // to communicate with the renderer thread since the browser's UI thread
   // could be stuck (within a Windows API call) trying to synchronously
   // communicate with the plug-in.  The remedy is to pump messages on this
@@ skipping 285 matching lines @@
     AddFilter(input_handler_manager_->GetMessageFilter());
   }
 
   scoped_refptr<base::MessageLoopProxy> output_surface_loop;
   if (enable)
     output_surface_loop = compositor_message_loop_proxy_;
   else
     output_surface_loop = base::MessageLoopProxy::current();
 
   compositor_output_surface_filter_ =
-      CompositorOutputSurface::CreateFilter(output_surface_loop);
+      CompositorOutputSurface::CreateFilter(output_surface_loop.get());
   AddFilter(compositor_output_surface_filter_.get());
 
   WebScriptController::enableV8SingleThreadMode();
 
   RenderThreadImpl::RegisterSchemes();
 
   webkit_glue::EnableWebCoreLogChannels(
       command_line.GetSwitchValueASCII(switches::kWebCoreLogChannels));
 
   web_database_observer_impl_.reset(
@@ skipping 207 matching lines @@
       WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
           this,
           attributes,
           GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext3d")));
 }
 
 scoped_refptr<ContextProviderCommandBuffer>
 RenderThreadImpl::OffscreenContextProviderForMainThread() {
   DCHECK(IsMainThread());
 
-  if (!shared_contexts_main_thread_ ||
+  if (!shared_contexts_main_thread_.get() ||
       shared_contexts_main_thread_->DestroyedOnMainThread()) {
     shared_contexts_main_thread_ =
         RendererContextProviderCommandBuffer::Create();
-    if (shared_contexts_main_thread_ &&
+    if (shared_contexts_main_thread_.get() &&
         !shared_contexts_main_thread_->BindToCurrentThread())
       shared_contexts_main_thread_ = NULL;
   }
   return shared_contexts_main_thread_;
 }
 
 scoped_refptr<ContextProviderCommandBuffer>
 RenderThreadImpl::OffscreenContextProviderForCompositorThread() {
   DCHECK(IsMainThread());
 
-  if (!shared_contexts_compositor_thread_ ||
+  if (!shared_contexts_compositor_thread_.get() ||
       shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
     shared_contexts_compositor_thread_ =
         RendererContextProviderCommandBuffer::Create();
   }
   return shared_contexts_compositor_thread_;
 }
 
 AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
   if (!audio_renderer_mixer_manager_) {
     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
@@ skipping 169 matching lines @@
       params.next_page_id,
       params.screen_info,
       params.accessibility_mode,
       params.allow_partial_swap);
 }
 
 GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
     CauseForGpuLaunch cause_for_gpu_launch) {
   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
 
-  if (gpu_channel_) {
+  if (gpu_channel_.get()) {
     // Do nothing if we already have a GPU channel or are already
     // establishing one.
     if (gpu_channel_->state() == GpuChannelHost::kUnconnected ||
         gpu_channel_->state() == GpuChannelHost::kConnected)
       return GetGpuChannel();
 
     // Recreate the channel if it has been lost.
     gpu_channel_ = NULL;
   }
 
@@ skipping 43 matching lines @@
   }
 #endif
   return media_stream_center_;
 }
 
 MediaStreamDependencyFactory*
 RenderThreadImpl::GetMediaStreamDependencyFactory() {
 #if defined(ENABLE_WEBRTC)
   if (!media_stream_factory_) {
     media_stream_factory_.reset(new MediaStreamDependencyFactory(
-        vc_manager_, p2p_socket_dispatcher_));
+        vc_manager_.get(), p2p_socket_dispatcher_.get()));
   }
 #endif
   return media_stream_factory_.get();
 }
 
 GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
-  if (!gpu_channel_)
+  if (!gpu_channel_.get())
     return NULL;
 
   if (gpu_channel_->state() != GpuChannelHost::kConnected)
     return NULL;
 
   return gpu_channel_.get();
 }
 
 void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
   EnsureWebKitInitialized();
@@ skipping 34 matching lines @@
 
 void RenderThreadImpl::SetFlingCurveParameters(
     const std::vector<float>& new_touchpad,
     const std::vector<float>& new_touchscreen) {
   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
                                                     new_touchscreen);
 
 }
 
 }  // namespace content