Remove unnecessary use of SupportsWeakPtr in content/browser/renderer_host

Most of them are replaced with WeakPtrFactory to avoid exposing AsWeakPtr()

BUG=None
TEST=build success


Review URL: https://chromiumcodereview.appspot.com/10824061

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@149375 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/renderer_host/buffered_resource_handler.cc

@@ -86,7 +86,8 @@ BufferedResourceHandler::BufferedResourceHandler(
       read_buffer_size_(0),
       bytes_read_(0),
       must_download_(false),
-      must_download_is_set_(false) {
+      must_download_is_set_(false),
+      weak_ptr_factory_(this) {
 }
 
 BufferedResourceHandler::~BufferedResourceHandler() {
@@ -197,7 +198,7 @@ void BufferedResourceHandler::Resume() {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&BufferedResourceHandler::CallReplayReadCompleted,
-                     AsWeakPtr()));
+                     weak_ptr_factory_.GetWeakPtr()));
       break;
     case STATE_STARTING:
     case STATE_STREAMING:
@@ -309,7 +310,8 @@ bool BufferedResourceHandler::SelectNextHandler(bool* defer) {
     if (stale) {
       // Refresh the plugins asynchronously.
       PluginServiceImpl::GetInstance()->GetPlugins(
-          base::Bind(&BufferedResourceHandler::OnPluginsLoaded, AsWeakPtr()));
+          base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
+                     weak_ptr_factory_.GetWeakPtr()));
       *defer = true;
       return true;
     }

content/browser/renderer_host/buffered_resource_handler.h

@@ -26,8 +26,7 @@ class ResourceDispatcherHostImpl;
 // Used to buffer a request until enough data has been received.
 class BufferedResourceHandler
     : public LayeredResourceHandler,
-      public ResourceController,
-      public base::SupportsWeakPtr<BufferedResourceHandler> {
+      public ResourceController {
  public:
   BufferedResourceHandler(scoped_ptr<ResourceHandler> next_handler,
                           ResourceDispatcherHostImpl* host,
@@ -105,6 +104,8 @@ class BufferedResourceHandler
   bool must_download_;
   bool must_download_is_set_;
 
+  base::WeakPtrFactory<BufferedResourceHandler> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(BufferedResourceHandler);
 };
 

content/browser/renderer_host/gpu_message_filter.cc

@@ -38,7 +38,8 @@ GpuMessageFilter::GpuMessageFilter(int render_process_id,
     : gpu_process_id_(0),
       render_process_id_(render_process_id),
       share_contexts_(false),
-      render_widget_helper_(render_widget_helper) {
+      render_widget_helper_(render_widget_helper),
+      weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
 #if defined(USE_AURA) || defined(OS_ANDROID)
@@ -113,7 +114,7 @@ void GpuMessageFilter::OnEstablishGpuChannel(
       render_process_id_,
       share_contexts_,
       base::Bind(&GpuMessageFilter::EstablishChannelCallback,
-                 AsWeakPtr(),
+                 weak_ptr_factory_.GetWeakPtr(),
                  reply));
 }
 
@@ -164,7 +165,7 @@ void GpuMessageFilter::OnCreateViewCommandBuffer(
       render_process_id_,
       init_params,
       base::Bind(&GpuMessageFilter::CreateCommandBufferCallback,
-                 AsWeakPtr(),
+                 weak_ptr_factory_.GetWeakPtr(),
                  reply));
 }
 

content/browser/renderer_host/gpu_message_filter.h

@@ -25,8 +25,7 @@ struct GPUInfo;
 // A message filter for messages from the renderer to the GpuProcessHost(UIShim)
 // in the browser. Such messages are typically destined for the GPU process,
 // but need to be mediated by the browser.
-class GpuMessageFilter : public BrowserMessageFilter,
-                         public base::SupportsWeakPtr<GpuMessageFilter> {
+class GpuMessageFilter : public BrowserMessageFilter {
  public:
   GpuMessageFilter(int render_process_id,
                    RenderWidgetHelper* render_widget_helper);
@@ -66,6 +65,8 @@ class GpuMessageFilter : public BrowserMessageFilter,
   scoped_refptr<RenderWidgetHelper> render_widget_helper_;
   std::vector<linked_ptr<CreateViewCommandBufferRequest> > pending_requests_;
 
+  base::WeakPtrFactory<GpuMessageFilter> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuMessageFilter);
 };
 

content/browser/renderer_host/media/media_stream_device_settings.cc

@@ -135,7 +135,8 @@ void DoDeviceRequest(
 MediaStreamDeviceSettings::MediaStreamDeviceSettings(
     SettingsRequester* requester)
     : requester_(requester),
-      use_fake_ui_(false) {
+      use_fake_ui_(false),
+      weak_ptr_factory_(this) {
   DCHECK(requester_);
 }
 
@@ -361,7 +362,7 @@ void MediaStreamDeviceSettings::PostRequestToUi(const std::string& label) {
   }
 
   scoped_refptr<ResponseCallbackHelper> helper =
-      new ResponseCallbackHelper(AsWeakPtr());
+      new ResponseCallbackHelper(weak_ptr_factory_.GetWeakPtr());
   content::MediaResponseCallback callback =
       base::Bind(&ResponseCallbackHelper::PostResponse,
                  helper.get(), label);

content/browser/renderer_host/media/media_stream_device_settings.h

@@ -32,8 +32,7 @@ class SettingsRequester;
 
 // MediaStreamDeviceSettings is responsible for getting user permission to use
 // a media capture device as well as selecting what device to use.
-class CONTENT_EXPORT MediaStreamDeviceSettings
-    : public base::SupportsWeakPtr<MediaStreamDeviceSettings> {
+class CONTENT_EXPORT MediaStreamDeviceSettings {
  public:
   explicit MediaStreamDeviceSettings(SettingsRequester* requester);
   virtual ~MediaStreamDeviceSettings();
@@ -88,6 +87,8 @@ class CONTENT_EXPORT MediaStreamDeviceSettings
   // See comment above for method UseFakeUI. Used for automated testing.
   bool use_fake_ui_;
 
+  base::WeakPtrFactory<MediaStreamDeviceSettings> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaStreamDeviceSettings);
 };
 

content/browser/renderer_host/render_widget_host_view_aura.cc

@@ -161,19 +161,19 @@ class RenderWidgetHostViewAura::WindowObserver : public aura::WindowObserver {
   DISALLOW_COPY_AND_ASSIGN(WindowObserver);
 };
 
-class RenderWidgetHostViewAura::ResizeLock
-    : public base::SupportsWeakPtr<RenderWidgetHostViewAura::ResizeLock> {
+class RenderWidgetHostViewAura::ResizeLock {
  public:
   ResizeLock(aura::RootWindow* root_window, const gfx::Size new_size)
       : root_window_(root_window),
         new_size_(new_size),
-        compositor_lock_(root_window_->GetCompositorLock()) {
+        compositor_lock_(root_window_->GetCompositorLock()),
+        weak_ptr_factory_(this) {
     root_window_->HoldMouseMoves();
 
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RenderWidgetHostViewAura::ResizeLock::CancelLock,
-                   AsWeakPtr()),
+                   weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kResizeLockTimeoutMs));
   }
 
@@ -201,6 +201,7 @@ class RenderWidgetHostViewAura::ResizeLock
   aura::RootWindow* root_window_;
   gfx::Size new_size_;
   scoped_refptr<aura::CompositorLock> compositor_lock_;
+  base::WeakPtrFactory<ResizeLock> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ResizeLock);
 };

content/browser/renderer_host/resource_dispatcher_host_impl.h

@@ -21,7 +21,6 @@
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "content/browser/download/download_resource_handler.h"
@@ -62,8 +61,7 @@ struct Referrer;
 
 class CONTENT_EXPORT ResourceDispatcherHostImpl
     : public ResourceDispatcherHost,
-      public ResourceLoaderDelegate,
-      public base::SupportsWeakPtr<ResourceDispatcherHostImpl> {
+      public ResourceLoaderDelegate {
  public:
   ResourceDispatcherHostImpl();
   virtual ~ResourceDispatcherHostImpl();

content/browser/renderer_host/resource_loader.cc

@@ -59,7 +59,8 @@ ResourceLoader::ResourceLoader(scoped_ptr<net::URLRequest> request,
       delegate_(delegate),
       last_upload_position_(0),
       waiting_for_upload_progress_ack_(false),
-      is_transferring_(false) {
+      is_transferring_(false),
+      weak_ptr_factory_(this) {
   request_->set_delegate(this);
   handler_->SetController(this);
 }
@@ -276,7 +277,7 @@ void ResourceLoader::OnSSLCertificateError(net::URLRequest* request,
     NOTREACHED();
 
   SSLManager::OnSSLCertificateError(
-      AsWeakPtr(),
+      weak_ptr_factory_.GetWeakPtr(),
       info->GetGlobalRequestID(),
       info->GetResourceType(),
       request_->url(),
@@ -381,13 +382,15 @@ void ResourceLoader::Resume() {
     case DEFERRED_READ:
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&ResourceLoader::ResumeReading, AsWeakPtr()));
+          base::Bind(&ResourceLoader::ResumeReading,
+                     weak_ptr_factory_.GetWeakPtr()));
       break;
     case DEFERRED_FINISH:
       // Delay self-destruction since we don't know how we were reached.
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&ResourceLoader::CallDidFinishLoading, AsWeakPtr()));
+          base::Bind(&ResourceLoader::CallDidFinishLoading,
+                     weak_ptr_factory_.GetWeakPtr()));
       break;
   }
 }
@@ -434,7 +437,8 @@ void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
     // notification from the request, so we have to signal ourselves to finish
     // this request.
     MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&ResourceLoader::ResponseCompleted, AsWeakPtr()));
+        FROM_HERE, base::Bind(&ResourceLoader::ResponseCompleted,
+                              weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
@@ -485,7 +489,8 @@ void ResourceLoader::StartReading(bool is_continuation) {
     // thread in case the URLRequest can provide data synchronously.
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&ResourceLoader::OnReadCompleted, AsWeakPtr(),
+        base::Bind(&ResourceLoader::OnReadCompleted,
+                   weak_ptr_factory_.GetWeakPtr(),
                    request_.get(), bytes_read));
   }
 }

content/browser/renderer_host/resource_loader.h

@@ -24,8 +24,7 @@ class ResourceRequestInfoImpl;
 // chain of ResourceHandlers, and is the ResourceController for its handler.
 class ResourceLoader : public net::URLRequest::Delegate,
                        public SSLErrorHandler::Delegate,
-                       public ResourceController,
-                       public base::SupportsWeakPtr<ResourceLoader> {
+                       public ResourceController {
  public:
   ResourceLoader(scoped_ptr<net::URLRequest> request,
                  scoped_ptr<ResourceHandler> handler,
@@ -114,6 +113,8 @@ class ResourceLoader : public net::URLRequest::Delegate,
   // which point we'll receive a new ResourceHandler.
   bool is_transferring_;
 
+  base::WeakPtrFactory<ResourceLoader> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ResourceLoader);
 };
 

content/browser/renderer_host/socket_stream_dispatcher_host.cc

@@ -25,7 +25,8 @@ SocketStreamDispatcherHost::SocketStreamDispatcherHost(
     ResourceContext* resource_context)
     : render_process_id_(render_process_id),
       url_request_context_selector_(selector),
-      resource_context_(resource_context) {
+      resource_context_(resource_context),
+      weak_ptr_factory_(this) {
   DCHECK(selector);
   net::WebSocketJob::EnsureInit();
 }
@@ -113,9 +114,9 @@ void SocketStreamDispatcherHost::OnSSLCertificateError(
   DCHECK(socket_stream_host);
   GlobalRequestID request_id(-1, socket_id);
   SSLManager::OnSSLCertificateError(
-      AsWeakPtr(), request_id, ResourceType::SUB_RESOURCE, socket->url(),
-      render_process_id_, socket_stream_host->render_view_id(), ssl_info,
-      fatal);
+      weak_ptr_factory_.GetWeakPtr(), request_id, ResourceType::SUB_RESOURCE,
+      socket->url(), render_process_id_, socket_stream_host->render_view_id(),
+      ssl_info, fatal);
 }
 
 bool SocketStreamDispatcherHost::CanGetCookies(net::SocketStream* socket,

content/browser/renderer_host/socket_stream_dispatcher_host.h

@@ -30,8 +30,7 @@ class ResourceContext;
 class SocketStreamDispatcherHost
     : public BrowserMessageFilter,
       public net::SocketStream::Delegate,
-      public SSLErrorHandler::Delegate,
-      public base::SupportsWeakPtr<SocketStreamDispatcherHost> {
+      public SSLErrorHandler::Delegate {
  public:
   SocketStreamDispatcherHost(
       int render_process_id,
@@ -87,6 +86,8 @@ class SocketStreamDispatcherHost
       url_request_context_selector_;
   ResourceContext* resource_context_;
 
+  base::WeakPtrFactory<SocketStreamDispatcherHost> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(SocketStreamDispatcherHost);
 };