Update content/ to use WeakPtr<T>::get() instead of implicit "operator T*"

content/renderer/pepper/pepper_broker_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_broker_impl.h"
 
 #include "build/build_config.h"
 #include "content/public/renderer/renderer_restrict_dispatch_group.h"
 #include "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 #include "content/renderer/pepper/pepper_proxy_channel_delegate_impl.h"
@@ skipping 94 matching lines @@
   }
 
   return result;
 }
 
 PepperBrokerImpl::PepperBrokerImpl(webkit::ppapi::PluginModule* plugin_module,
                                    PepperPluginDelegateImpl* delegate)
     : plugin_module_(plugin_module),
       delegate_(delegate->AsWeakPtr()) {
   DCHECK(plugin_module_);
-  DCHECK(delegate_);
+  DCHECK(delegate_.get());
 
   plugin_module_->SetBroker(this);
 }
 
 PepperBrokerImpl::~PepperBrokerImpl() {
   ReportFailureToClients(PP_ERROR_ABORTED);
   plugin_module_->SetBroker(NULL);
   plugin_module_ = NULL;
 }
 
@@ skipping 28 matching lines @@
     // called to remove this object from pending_connect_broker_.
     // Before the broker is connected, clients must either be in
     // pending_connects_ or not yet associated with this object. Thus, if this
     // object is in pending_connect_broker_, there can be no associated clients
     // once pending_connects_ is empty and it is thus safe to remove this from
     // pending_connect_broker_. Doing so will cause this object to be deleted,
     // removing it from the PluginModule. Any new clients will create a new
     // instance of this object.
     // This doesn't solve all potential problems, but it helps with the ones
     // we can influence.
-    if (delegate_) {
+    if (delegate_.get()) {
       bool stopped = delegate_->StopWaitingForBrokerConnection(this);
 
       // Verify the assumption that there are no references other than the one
       // |client| holds, which will be released below.
       DCHECK(!stopped || HasOneRef());
     }
   }
 
   // Release the reference added in Connect().
   // This must be the last statement because it may delete this object.
@@ skipping 15 matching lines @@
   // Process all pending channel requests from the plugins.
   for (ClientMap::iterator i = pending_connects_.begin();
        i != pending_connects_.end();) {
     base::WeakPtr<webkit::ppapi::PPB_Broker_Impl>& weak_ptr =
         i->second.client;
     if (!i->second.is_authorized) {
       ++i;
       continue;
     }
 
-    if (weak_ptr)
-      ConnectPluginToBroker(weak_ptr);
+    if (weak_ptr.get())
+      ConnectPluginToBroker(weak_ptr.get());
 
     pending_connects_.erase(i++);
   }
 }
 
 void PepperBrokerImpl::OnBrokerPermissionResult(
     webkit::ppapi::PPB_Broker_Impl* client,
     bool result) {
   ClientMap::iterator entry = pending_connects_.find(client);
   if (entry == pending_connects_.end())
     return;
 
-  if (!entry->second.client) {
+  if (!entry->second.client.get()) {
     // Client has gone away.
     pending_connects_.erase(entry);
     return;
   }
 
   if (!result) {
     // Report failure.
     client->BrokerConnected(
         ppapi::PlatformFileToInt(base::kInvalidPlatformFileValue),
         PP_ERROR_NOACCESS);
@@ skipping 19 matching lines @@
 
 PepperBrokerImpl::PendingConnection::~PendingConnection() {
 }
 
 void PepperBrokerImpl::ReportFailureToClients(int error_code) {
   DCHECK_NE(PP_OK, error_code);
   for (ClientMap::iterator i = pending_connects_.begin();
        i != pending_connects_.end(); ++i) {
     base::WeakPtr<webkit::ppapi::PPB_Broker_Impl>& weak_ptr =
         i->second.client;
-    if (weak_ptr) {
+    if (weak_ptr.get()) {
       weak_ptr->BrokerConnected(
           ppapi::PlatformFileToInt(base::kInvalidPlatformFileValue),
           error_code);
     }
   }
   pending_connects_.clear();
 }
 
 void PepperBrokerImpl::ConnectPluginToBroker(
     webkit::ppapi::PPB_Broker_Impl* client) {
@@ skipping 18 matching lines @@
 
   // TOOD(ddorwin): Change the IPC to asynchronous: Queue an object containing
   // client and plugin_socket.release(), then return.
   // That message handler will then call client->BrokerConnected() with the
   // saved pipe handle.
   // Temporarily, just call back.
   client->BrokerConnected(ppapi::PlatformFileToInt(plugin_handle), result);
 }
 
 }  // namespace content