Remove all but one use of WeakPtrFactory::DetachFromThread

ui/gl/gl_surface_glx.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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
@@ skipping 105 matching lines @@
     DCHECK(CalledOnValidThread());
     g_video_sync_thread = NULL;
     Stop();
   }
 
   static SGIVideoSyncThread* g_video_sync_thread;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncThread);
 };
 
-class SGIVideoSyncProviderThreadShim
-    : public base::SupportsWeakPtr<SGIVideoSyncProviderThreadShim> {
+class SGIVideoSyncProviderThreadShim {
  public:
   explicit SGIVideoSyncProviderThreadShim(XID window)
       : window_(window),
         context_(NULL),
         message_loop_(base::MessageLoopProxy::current()),
         cancel_vsync_flag_(),
         vsync_lock_() {
     // This ensures that creation of |window_| has occured when this shim
     // is executing in the same process as the call to create |window_|.
     XSync(g_display, False);
   }
 
+  virtual ~SGIVideoSyncProviderThreadShim() {
+    if (context_) {
+      glXDestroyContext(display_, context_);
+      context_ = NULL;
+    }
+  }
+
   base::CancellationFlag* cancel_vsync_flag() {
     return &cancel_vsync_flag_;
   }
 
   base::Lock* vsync_lock() {
     return &vsync_lock_;
   }
 
   void Initialize() {
     DCHECK(display_);
@@ skipping 17 matching lines @@
     if (visual_info_count == 0) {
       LOG(ERROR) << "No visual info for visual ID.";
       return;
     }
 
     context_ = glXCreateContext(display_, visual_info_list.get(), NULL, True);
 
     DCHECK(NULL != context_);
   }
 
-  void Destroy() {
-    if (context_) {
-      glXDestroyContext(display_, context_);
-      context_ = NULL;
-    }
-    delete this;
-  }
-
   void GetVSyncParameters(const VSyncProvider::UpdateVSyncCallback& callback) {
     base::TimeTicks now;
     {
       // Don't allow |window_| destruction while we're probing vsync.
       base::AutoLock locked(vsync_lock_);
 
       if (!context_ || cancel_vsync_flag_.IsSet())
         return;
 
       glXMakeCurrent(display_, window_, context_);
@@ skipping 13 matching lines @@
 
     message_loop_->PostTask(
         FROM_HERE, base::Bind(callback, now, kDefaultInterval));
   }
 
  private:
   // For initialization of display_ in GLSurface::InitializeOneOff before
   // the sandbox goes up.
   friend class gfx::GLSurfaceGLX;
 
-  virtual ~SGIVideoSyncProviderThreadShim() {
-  }
-
   static Display* display_;
 
   XID window_;
   GLXContext context_;
 
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   base::CancellationFlag cancel_vsync_flag_;
   base::Lock vsync_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncProviderThreadShim);
 };
 
 class SGIVideoSyncVSyncProvider
     : public gfx::VSyncProvider,
       public base::SupportsWeakPtr<SGIVideoSyncVSyncProvider> {
  public:
   explicit SGIVideoSyncVSyncProvider(gfx::AcceleratedWidget window)
       : vsync_thread_(SGIVideoSyncThread::Create()),
-        shim_((new SGIVideoSyncProviderThreadShim(window))->AsWeakPtr()),
+        shim_(new SGIVideoSyncProviderThreadShim(window)),
         cancel_vsync_flag_(shim_->cancel_vsync_flag()),
         vsync_lock_(shim_->vsync_lock()) {
-    // The WeakPtr is bound to the SGIVideoSyncThread. We only use it for
-    // PostTask.
-    shim_->DetachFromThread();
     vsync_thread_->message_loop()->PostTask(
         FROM_HERE,
-        base::Bind(&SGIVideoSyncProviderThreadShim::Initialize, shim_));
+        base::Bind(&SGIVideoSyncProviderThreadShim::Initialize,
+                   base::Unretained(shim_.get())));
   }
 
   virtual ~SGIVideoSyncVSyncProvider() {
     {
       base::AutoLock locked(*vsync_lock_);
       cancel_vsync_flag_->Set();
     }
-    vsync_thread_->message_loop()->PostTask(
+
+    // Hand-off |shim_| to be deleted on the |vsync_thread_|.
+    vsync_thread_->message_loop()->DeleteSoon(
         FROM_HERE,
-        base::Bind(&SGIVideoSyncProviderThreadShim::Destroy, shim_));
+        shim_.release());
   }
 
   virtual void GetVSyncParameters(
       const VSyncProvider::UpdateVSyncCallback& callback) OVERRIDE {
     // Only one outstanding request per surface.
     if (!pending_callback_) {
       pending_callback_.reset(
           new VSyncProvider::UpdateVSyncCallback(callback));
       vsync_thread_->message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&SGIVideoSyncProviderThreadShim::GetVSyncParameters,
-                     shim_, base::Bind(
+                     base::Unretained(shim_.get()),
+                     base::Bind(
                          &SGIVideoSyncVSyncProvider::PendingCallbackRunner,
                          AsWeakPtr())));
     }
   }
 
  private:
   void PendingCallbackRunner(const base::TimeTicks timebase,
                              const base::TimeDelta interval) {
     DCHECK(pending_callback_);
     pending_callback_->Run(timebase, interval);
     pending_callback_.reset();
   }
 
   scoped_refptr<SGIVideoSyncThread> vsync_thread_;
-  base::WeakPtr<SGIVideoSyncProviderThreadShim> shim_;
+
+  // Thread shim through which the sync provider is accessed on |vsync_thread_|.
+  scoped_ptr<SGIVideoSyncProviderThreadShim> shim_;
 
   scoped_ptr<VSyncProvider::UpdateVSyncCallback> pending_callback_;
 
   // Raw pointers to sync primitives owned by the shim_.
   // These will only be referenced before we post a task to destroy
   // the shim_, so they are safe to access.
   base::CancellationFlag* cancel_vsync_flag_;
   base::Lock* vsync_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncVSyncProvider);
@@ skipping 319 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx