Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

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 392 matching lines @@
     media::InitializeMediaLibrary(media_path);
 
   TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
 
   // Wait for all databases to be closed.
-  if (web_database_observer_impl_.get())
+  if (web_database_observer_impl_)
     web_database_observer_impl_->WaitForAllDatabasesToClose();
 
   // Shutdown in reverse of the initialization order.
-  if (devtools_agent_message_filter_.get()) {
+  if (devtools_agent_message_filter_) {
     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_.get())
+  if (file_thread_)
     file_thread_->Stop();
 
-  if (compositor_output_surface_filter_.get()) {
+  if (compositor_output_surface_filter_) {
     RemoveFilter(compositor_output_surface_filter_.get());
     compositor_output_surface_filter_ = NULL;
   }
 
   compositor_thread_.reset();
-  if (input_handler_manager_.get()) {
+  if (input_handler_manager_) {
     RemoveFilter(input_handler_manager_->GetMessageFilter());
     input_handler_manager_.reset();
   }
 
-  if (webkit_platform_support_.get())
+  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
 
@@ skipping 155 matching lines @@
   DCHECK_GT(hidden_widget_count_, 0);
   hidden_widget_count_--;
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::EnsureWebKitInitialized() {
-  if (webkit_platform_support_.get())
+  if (webkit_platform_support_)
     return;
 
   webkit_platform_support_.reset(new RendererWebKitPlatformSupportImpl);
   WebKit::initialize(webkit_platform_support_.get());
   WebKit::setSharedWorkerRepository(
       webkit_platform_support_.get()->sharedWorkerRepository());
   WebKit::setIDBFactory(
       webkit_platform_support_.get()->idbFactory());
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
@@ skipping 282 matching lines @@
 }
 
 void RenderThreadImpl::PostponeIdleNotification() {
   idle_notifications_to_skip_ = 2;
 }
 
 /* static */
 void RenderThreadImpl::OnGpuVDAContextLoss() {
   RenderThreadImpl* self = RenderThreadImpl::current();
   DCHECK(self);
-  if (!self->gpu_vda_context3d_.get())
+  if (!self->gpu_vda_context3d_)
     return;
   if (self->compositor_message_loop_proxy()) {
     self->compositor_message_loop_proxy()->DeleteSoon(
         FROM_HERE, self->gpu_vda_context3d_.release());
   } else {
     self->gpu_vda_context3d_.reset();
   }
 }
 
 WebGraphicsContext3DCommandBufferImpl*
 RenderThreadImpl::GetGpuVDAContext3D() {
-  if (!gpu_vda_context3d_.get()) {
+  if (!gpu_vda_context3d_) {
     gpu_vda_context3d_.reset(
         WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
             this, WebKit::WebGraphicsContext3D::Attributes(),
             GURL("chrome://gpu/RenderThreadImpl::GetGpuVDAContext3D")));
-    if (gpu_vda_context3d_.get())
+    if (gpu_vda_context3d_)
       gpu_vda_context3d_->setContextLostCallback(context_lost_cb_.get());
   }
   return gpu_vda_context3d_.get();
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 RenderThreadImpl::CreateOffscreenContext3d() {
   WebKit::WebGraphicsContext3D::Attributes attributes;
   attributes.shareResources = true;
   attributes.depth = false;
@@ skipping 29 matching lines @@
 
   if (!shared_contexts_compositor_thread_ ||
       shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
     shared_contexts_compositor_thread_ =
         RendererContextProviderCommandBuffer::Create();
   }
   return shared_contexts_compositor_thread_;
 }
 
 AudioRendererMixerManager* RenderThreadImpl::GetAudioRendererMixerManager() {
-  if (!audio_renderer_mixer_manager_.get()) {
+  if (!audio_renderer_mixer_manager_) {
     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
         GetAudioHardwareConfig()));
   }
 
   return audio_renderer_mixer_manager_.get();
 }
 
 media::AudioHardwareConfig* RenderThreadImpl::GetAudioHardwareConfig() {
   if (!audio_hardware_config_) {
     media::AudioParameters input_params;
@@ skipping 158 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_.get()) {
+  if (gpu_channel_) {
     // 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 41 matching lines @@
           client, GetMediaStreamDependencyFactory());
     }
   }
 #endif
   return media_stream_center_;
 }
 
 MediaStreamDependencyFactory*
 RenderThreadImpl::GetMediaStreamDependencyFactory() {
 #if defined(ENABLE_WEBRTC)
-  if (!media_stream_factory_.get()) {
+  if (!media_stream_factory_) {
     media_stream_factory_.reset(new MediaStreamDependencyFactory(
         vc_manager_, p2p_socket_dispatcher_));
   }
 #endif
   return media_stream_factory_.get();
 }
 
 GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
-  if (!gpu_channel_.get())
+  if (!gpu_channel_)
     return NULL;
 
   if (gpu_channel_->state() != GpuChannelHost::kConnected)
     return NULL;
 
   return gpu_channel_.get();
 }
 
 void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
   EnsureWebKitInitialized();
@@ skipping 18 matching lines @@
   CHECK(false);
 }
 
 void RenderThreadImpl::OnSetWebKitSharedTimersSuspended(bool suspend) {
   ToggleWebKitSharedTimer(suspend);
 }
 
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
-  if (!file_thread_.get()) {
+  if (!file_thread_) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }
 
 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