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

content/browser/browser_plugin/test_browser_plugin_guest.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_plugin/test_browser_plugin_guest.h"
 
 #include "base/test/test_timeouts.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
@@ skipping 35 matching lines @@
 }
 
 void TestBrowserPluginGuest::Observe(int type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED: {
       bool visible = *Details<bool>(details).ptr();
       if (!visible) {
         was_hidden_observed_ = true;
-        if (was_hidden_message_loop_runner_)
+        if (was_hidden_message_loop_runner_.get())
           was_hidden_message_loop_runner_->Quit();
       }
       return;
     }
   }
 
   BrowserPluginGuest::Observe(type, source, details);
 }
 
 void TestBrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
   if (msg->type() == BrowserPluginMsg_UpdateRect::ID) {
     update_rect_count_++;
     int instance_id = 0;
     BrowserPluginMsg_UpdateRect_Params params;
     BrowserPluginMsg_UpdateRect::Read(msg, &instance_id, &params);
     last_view_size_observed_ = params.view_size;
     if (!expected_auto_view_size_.IsEmpty() &&
         expected_auto_view_size_ == params.view_size) {
-      if (auto_view_size_message_loop_runner_)
+      if (auto_view_size_message_loop_runner_.get())
         auto_view_size_message_loop_runner_->Quit();
     }
-    if (send_message_loop_runner_)
+    if (send_message_loop_runner_.get())
       send_message_loop_runner_->Quit();
   }
   BrowserPluginGuest::SendMessageToEmbedder(msg);
 }
 
 void TestBrowserPluginGuest::WaitForUpdateRectMsg() {
   // Check if we already got any UpdateRect message.
   if (update_rect_count_ > 0)
     return;
   send_message_loop_runner_ = new MessageLoopRunner();
@@ skipping 13 matching lines @@
   waiting_for_damage_buffer_with_size_ = true;
   damage_buffer_message_loop_runner_ = new MessageLoopRunner();
   damage_buffer_message_loop_runner_->Run();
 }
 
 void TestBrowserPluginGuest::RenderViewGone(base::TerminationStatus status) {
   exit_observed_ = true;
   if (status != base::TERMINATION_STATUS_NORMAL_TERMINATION &&
       status != base::TERMINATION_STATUS_STILL_RUNNING)
     LOG(INFO) << "Guest crashed status: " << status;
-  if (crash_message_loop_runner_)
+  if (crash_message_loop_runner_.get())
     crash_message_loop_runner_->Quit();
   BrowserPluginGuest::RenderViewGone(status);
 }
 
 void TestBrowserPluginGuest::OnHandleInputEvent(
     int instance_id,
     const gfx::Rect& guest_window_rect,
     const WebKit::WebInputEvent* event) {
   BrowserPluginGuest::OnHandleInputEvent(instance_id,
                                          guest_window_rect,
                                          event);
   input_observed_ = true;
-  if (input_message_loop_runner_)
+  if (input_message_loop_runner_.get())
     input_message_loop_runner_->Quit();
 }
 
 void TestBrowserPluginGuest::WaitForExit() {
   // Check if we already observed a guest crash, return immediately if so.
   if (exit_observed_)
     return;
 
   crash_message_loop_runner_ = new MessageLoopRunner();
   crash_message_loop_runner_->Run();
@@ skipping 88 matching lines @@
 
   expected_auto_view_size_ = view_size;
   auto_view_size_message_loop_runner_ = new MessageLoopRunner();
   auto_view_size_message_loop_runner_->Run();
   last_view_size_observed_ = gfx::Size();
 }
 
 void TestBrowserPluginGuest::OnSetFocus(int instance_id, bool focused) {
   if (focused) {
     focus_observed_ = true;
-    if (focus_message_loop_runner_)
+    if (focus_message_loop_runner_.get())
       focus_message_loop_runner_->Quit();
   } else {
     blur_observed_ = true;
-    if (blur_message_loop_runner_)
+    if (blur_message_loop_runner_.get())
       blur_message_loop_runner_->Quit();
   }
   BrowserPluginGuest::OnSetFocus(instance_id, focused);
 }
 
 void TestBrowserPluginGuest::OnTakeFocus(bool reverse) {
   advance_focus_observed_ = true;
-  if (advance_focus_message_loop_runner_)
+  if (advance_focus_message_loop_runner_.get())
     advance_focus_message_loop_runner_->Quit();
   BrowserPluginGuest::OnTakeFocus(reverse);
 }
 
 void TestBrowserPluginGuest::OnReload(int instance_id) {
   reload_observed_ = true;
-  if (reload_message_loop_runner_)
+  if (reload_message_loop_runner_.get())
     reload_message_loop_runner_->Quit();
   BrowserPluginGuest::OnReload(instance_id);
 }
 
 void TestBrowserPluginGuest::OnStop(int instance_id) {
   stop_observed_ = true;
-  if (stop_message_loop_runner_)
+  if (stop_message_loop_runner_.get())
     stop_message_loop_runner_->Quit();
   BrowserPluginGuest::OnStop(instance_id);
 }
 
 void TestBrowserPluginGuest::SetDamageBuffer(
     const BrowserPluginHostMsg_ResizeGuest_Params& params) {
   ++damage_buffer_call_count_;
   last_damage_buffer_size_ = params.view_rect.size();
 
   if (waiting_for_damage_buffer_with_size_ &&
       expected_damage_buffer_size_ == params.view_rect.size() &&
-      damage_buffer_message_loop_runner_) {
+      damage_buffer_message_loop_runner_.get()) {
     damage_buffer_message_loop_runner_->Quit();
     waiting_for_damage_buffer_with_size_ = false;
   }
 
   BrowserPluginGuest::SetDamageBuffer(params);
 }
 
 void TestBrowserPluginGuest::DidStopLoading(
     RenderViewHost* render_view_host) {
   BrowserPluginGuest::DidStopLoading(render_view_host);
   load_stop_observed_ = true;
-  if (load_stop_message_loop_runner_)
+  if (load_stop_message_loop_runner_.get())
     load_stop_message_loop_runner_->Quit();
 }
 
 }  // namespace content