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

content/browser/browser_main_loop.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/browser/browser_main_loop.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hi_res_timer_manager.h"
@@ skipping 291 matching lines @@
 void BrowserMainLoop::EarlyInitialization() {
 #if defined(USE_X11)
   if (parsed_command_line_.HasSwitch(switches::kSingleProcess) ||
       parsed_command_line_.HasSwitch(switches::kInProcessGPU)) {
     if (!XInitThreads()) {
       LOG(ERROR) << "Failed to put Xlib into threaded mode.";
     }
   }
 #endif
 
-  if (parts_.get())
+  if (parts_)
     parts_->PreEarlyInitialization();
 
 #if defined(OS_WIN)
   net::EnsureWinsockInit();
 #endif
 
 #if !defined(USE_OPENSSL)
   // We want to be sure to init NSPR on the main thread.
   crypto::EnsureNSPRInit();
 #endif  // !defined(USE_OPENSSL)
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   SetupSandbox(parsed_command_line_);
 #endif
 
   if (parsed_command_line_.HasSwitch(switches::kEnableSSLCachedInfo))
     net::SSLConfigService::EnableCachedInfo();
 
 #if !defined(OS_IOS)
   if (parsed_command_line_.HasSwitch(switches::kRendererProcessLimit)) {
     std::string limit_string = parsed_command_line_.GetSwitchValueASCII(
         switches::kRendererProcessLimit);
     size_t process_limit;
     if (base::StringToSizeT(limit_string, &process_limit)) {
       RenderProcessHost::SetMaxRendererProcessCount(process_limit);
     }
   }
 #endif  // !defined(OS_IOS)
 
-  if (parts_.get())
+  if (parts_)
     parts_->PostEarlyInitialization();
 }
 
 void BrowserMainLoop::MainMessageLoopStart() {
-  if (parts_.get())
+  if (parts_)
     parts_->PreMainMessageLoopStart();
 
 #if defined(OS_WIN)
   // If we're running tests (ui_task is non-null), then the ResourceBundle
   // has already been initialized.
   if (!parameters_.ui_task) {
     // Override the configured locale with the user's preferred UI language.
     l10n_util::OverrideLocaleWithUILanguageList();
   }
 #endif
@@ skipping 30 matching lines @@
   // plugin service as it is predominantly used from the io thread,
   // but must be created on the main thread. The service ctor is
   // inexpensive and does not invoke the io_thread() accessor.
   PluginService::GetInstance()->Init();
 #endif
 
 #if defined(OS_WIN)
   system_message_window_.reset(new SystemMessageWindowWin);
 #endif
 
-  if (parts_.get())
+  if (parts_)
     parts_->PostMainMessageLoopStart();
 
 #if defined(OS_ANDROID)
   SurfaceTexturePeer::InitInstance(new SurfaceTexturePeerBrowserImpl());
   DataFetcherImplAndroid::Init(base::android::AttachCurrentThread());
 #endif
 
   if (parsed_command_line_.HasSwitch(switches::kMemoryMetrics)) {
     memory_observer_.reset(new MemoryObserver());
     MessageLoop::current()->AddTaskObserver(memory_observer_.get());
   }
 }
 
 void BrowserMainLoop::CreateThreads() {
-  if (parts_.get())
+  if (parts_)
     result_code_ = parts_->PreCreateThreads();
 
 #if !defined(OS_IOS) && (!defined(GOOGLE_CHROME_BUILD) || defined(OS_ANDROID))
   // Single-process is an unsupported and not fully tested mode, so
   // don't enable it for official Chrome builds (except on Android).
   if (parsed_command_line_.HasSwitch(switches::kSingleProcess))
     RenderProcessHost::SetRunRendererInProcess(true);
 #endif
 
   if (result_code_ > 0)
@@ skipping 66 matching lines @@
     } else if (thread_to_start) {
       (*thread_to_start).reset(new BrowserProcessSubThread(id));
       (*thread_to_start)->StartWithOptions(*options);
     } else {
       NOTREACHED();
     }
   }
 
   BrowserThreadsStarted();
 
-  if (parts_.get())
+  if (parts_)
     parts_->PreMainMessageLoopRun();
 
   // If the UI thread blocks, the whole UI is unresponsive.
   // Do not allow disk IO from the UI thread.
   base::ThreadRestrictions::SetIOAllowed(false);
   base::ThreadRestrictions::DisallowWaiting();
 }
 
 void BrowserMainLoop::RunMainMessageLoopParts() {
   TRACE_EVENT_BEGIN_ETW("BrowserMain:MESSAGE_LOOP", 0, "");
 
   bool ran_main_loop = false;
-  if (parts_.get())
+  if (parts_)
     ran_main_loop = parts_->MainMessageLoopRun(&result_code_);
 
   if (!ran_main_loop)
     MainMessageLoopRun();
 
   TRACE_EVENT_END_ETW("BrowserMain:MESSAGE_LOOP", 0, "");
 }
 
 void BrowserMainLoop::ShutdownThreadsAndCleanUp() {
   // Teardown may start in PostMainMessageLoopRun, and during teardown we
   // need to be able to perform IO.
   base::ThreadRestrictions::SetIOAllowed(true);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(base::IgnoreResult(&base::ThreadRestrictions::SetIOAllowed),
                  true));
 
-  if (parts_.get())
+  if (parts_)
     parts_->PostMainMessageLoopRun();
 
 #if !defined(OS_IOS)
   // Destroying the GpuProcessHostUIShims on the UI thread posts a task to
   // delete related objects on the GPU thread. This must be done before
   // stopping the GPU thread. The GPU thread will close IPC channels to renderer
   // processes so this has to happen before stopping the IO thread.
   GpuProcessHostUIShim::DestroyAll();
 
   // Cancel pending requests and prevent new requests.
-  if (resource_dispatcher_host_.get())
+  if (resource_dispatcher_host_)
     resource_dispatcher_host_.get()->Shutdown();
 
 #if defined(USE_AURA)
   ImageTransportFactory::Terminate();
 #endif
 
   // The device monitors are using |system_monitor_| as dependency, so delete
   // them before |system_monitor_| goes away.
   // On Mac and windows, the monitor needs to be destroyed on the same thread
   // as they were created. On Linux, the monitor will be deleted when IO thread
@@ skipping 47 matching lines @@
         break;
       case BrowserThread::FILE_USER_BLOCKING:
         thread_to_stop = &file_user_blocking_thread_;
         break;
       case BrowserThread::FILE:
         thread_to_stop = &file_thread_;
 
 #if !defined(OS_IOS)
         // Clean up state that lives on or uses the file_thread_ before
         // it goes away.
-        if (resource_dispatcher_host_.get())
+        if (resource_dispatcher_host_)
           resource_dispatcher_host_.get()->save_file_manager()->Shutdown();
 #endif  // !defined(OS_IOS)
         break;
       case BrowserThread::PROCESS_LAUNCHER:
         thread_to_stop = &process_launcher_thread_;
         break;
       case BrowserThread::CACHE:
         thread_to_stop = &cache_thread_;
         break;
       case BrowserThread::IO:
@@ skipping 32 matching lines @@
   // it.
   BrowserGpuChannelHostFactory::Terminate();
 
   // Must happen after the I/O thread is shutdown since this class lives on the
   // I/O thread and isn't threadsafe.
   GamepadService::GetInstance()->Terminate();
 
   URLDataManager::DeleteDataSources();
 #endif  // !defined(OS_IOS)
 
-  if (parts_.get())
+  if (parts_)
     parts_->PostDestroyThreads();
 }
 
 void BrowserMainLoop::InitializeMainThread() {
   const char* kThreadName = "CrBrowserMain";
   base::PlatformThread::SetName(kThreadName);
-  if (main_message_loop_.get())
+  if (main_message_loop_)
     main_message_loop_->set_thread_name(kThreadName);
 
   // Register the main thread by instantiating it, but don't call any methods.
   main_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
                                            MessageLoop::current()));
 }
 
 #if defined(OS_ANDROID)
 // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
 namespace {
@@ skipping 110 matching lines @@
 
 #if defined(OS_WIN)
   // Init common control sex.
   INITCOMMONCONTROLSEX config;
   config.dwSize = sizeof(config);
   config.dwICC = ICC_WIN95_CLASSES;
   if (!InitCommonControlsEx(&config))
     LOG_GETLASTERROR(FATAL);
 #endif
 
-  if (parts_.get())
+  if (parts_)
     parts_->ToolkitInitialized();
 }
 
 void BrowserMainLoop::MainMessageLoopRun() {
 #if defined(OS_ANDROID)
   // Android's main message loop is the Java message loop.
   NOTREACHED();
 #else
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
   if (parameters_.ui_task)
     MessageLoopForUI::current()->PostTask(FROM_HERE, *parameters_.ui_task);
 
   base::RunLoop run_loop;
   run_loop.Run();
 #endif
 }
 
 }  // namespace content