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

content/renderer/pepper/pepper_plugin_delegate_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/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 328 matching lines @@
 }
 
 WebKit::WebPlugin* PepperPluginDelegateImpl::CreatePepperWebPlugin(
     const webkit::WebPluginInfo& webplugin_info,
     const WebKit::WebPluginParams& params) {
   bool pepper_plugin_was_registered = false;
   scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
       CreatePepperPluginModule(webplugin_info, &pepper_plugin_was_registered));
 
   if (pepper_plugin_was_registered) {
-    if (!pepper_module)
+    if (!pepper_module.get())
       return NULL;
     return new webkit::ppapi::WebPluginImpl(
         pepper_module.get(), params, AsWeakPtr());
   }
 
   return NULL;
 }
 
 scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPluginModule(
     const webkit::WebPluginInfo& webplugin_info,
     bool* pepper_plugin_was_registered) {
   *pepper_plugin_was_registered = true;
 
   // See if a module has already been loaded for this plugin.
   base::FilePath path(webplugin_info.path);
   scoped_refptr<webkit::ppapi::PluginModule> module =
       PepperPluginRegistry::GetInstance()->GetLiveModule(path);
-  if (module) {
+  if (module.get()) {
     if (!module->GetEmbedderState()) {
       // If the module exists and no embedder state was associated with it,
       // then the module was one of the ones preloaded and is an in-process
       // plugin. We need to associate our host state with it.
-      CreateHostForInProcessModule(render_view_, module, webplugin_info);
+      CreateHostForInProcessModule(render_view_, module.get(), webplugin_info);
     }
     return module;
   }
 
   // In-process plugins will have always been created up-front to avoid the
   // sandbox restrictions. So getting here implies it doesn't exist or should
   // be out of process.
   const PepperPluginInfo* info =
       PepperPluginRegistry::GetInstance()->GetInfoForPlugin(webplugin_info);
   if (!info) {
@@ skipping 17 matching lines @@
     // Couldn't be initialized.
     return scoped_refptr<webkit::ppapi::PluginModule>();
   }
 
   // AddLiveModule must be called before any early returns since the
   // module's destructor will remove itself.
   module = new webkit::ppapi::PluginModule(
       info->name, path,
       PepperPluginRegistry::GetInstance(),
       permissions);
-  PepperPluginRegistry::GetInstance()->AddLiveModule(path, module);
+  PepperPluginRegistry::GetInstance()->AddLiveModule(path, module.get());
 
-  if (!CreateOutOfProcessModule(module,
+  if (!CreateOutOfProcessModule(module.get(),
                                 path,
                                 permissions,
                                 channel_handle,
                                 peer_pid,
                                 plugin_child_id,
                                 false))  // is_external = false
     return scoped_refptr<webkit::ppapi::PluginModule>();
 
   return module;
 }
 
 RendererPpapiHost* PepperPluginDelegateImpl::CreateExternalPluginModule(
     scoped_refptr<webkit::ppapi::PluginModule> module,
     const base::FilePath& path,
     ppapi::PpapiPermissions permissions,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessId peer_pid,
     int plugin_child_id) {
   // We don't call PepperPluginRegistry::AddLiveModule, as this module is
   // managed externally.
-  return CreateOutOfProcessModule(module,
+  return CreateOutOfProcessModule(module.get(),
                                   path,
                                   permissions,
                                   channel_handle,
                                   peer_pid,
                                   plugin_child_id,
                                   true);  // is_external = true
 }
 
 scoped_refptr<PepperBrokerImpl> PepperPluginDelegateImpl::CreateBroker(
     webkit::ppapi::PluginModule* plugin_module) {
@@ skipping 446 matching lines @@
     webkit::ppapi::PPB_Broker_Impl* client) {
   DCHECK(client);
 
   webkit::ppapi::PluginModule* plugin_module =
       webkit::ppapi::ResourceHelper::GetPluginModule(client);
   if (!plugin_module)
     return NULL;
 
   scoped_refptr<PepperBrokerImpl> broker =
       static_cast<PepperBrokerImpl*>(plugin_module->GetBroker());
-  if (!broker) {
+  if (!broker.get()) {
     broker = CreateBroker(plugin_module);
-    if (!broker)
+    if (!broker.get())
       return NULL;
   }
 
   int request_id = pending_permission_requests_.Add(
       new base::WeakPtr<webkit::ppapi::PPB_Broker_Impl>(client->AsWeakPtr()));
   if (!render_view_->Send(
           new ViewHostMsg_RequestPpapiBrokerPermission(
               render_view_->routing_id(),
               request_id,
               client->GetDocumentUrl(),
               plugin_module->path()))) {
     return NULL;
   }
 
   // Adds a reference, ensuring that the broker is not deleted when
   // |broker| goes out of scope.
   broker->AddPendingConnect(client);
 
-  return broker;
+  return broker.get();
 }
 
 void PepperPluginDelegateImpl::OnPpapiBrokerPermissionResult(
     int request_id,
     bool result) {
   scoped_ptr<base::WeakPtr<webkit::ppapi::PPB_Broker_Impl> > client_ptr(
       pending_permission_requests_.Lookup(request_id));
   DCHECK(client_ptr.get());
   pending_permission_requests_.Remove(request_id);
   base::WeakPtr<webkit::ppapi::PPB_Broker_Impl> client = *client_ptr;
@@ skipping 753 matching lines @@
       should_close_source);
 }
 
 bool PepperPluginDelegateImpl::IsRunningInProcess(PP_Instance instance) const {
   RendererPpapiHostImpl* host =
       RendererPpapiHostImpl::GetForPPInstance(instance);
   return host && host->IsRunningInProcess();
 }
 
 }  // namespace content