Remove base::Callback from ContextProvider creation.

content/browser/aura/gpu_process_transport_factory.cc

 // Copyright (c) 2013 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/aura/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 206 matching lines @@
     ui::Compositor* compositor) {
   PerCompositorData* data = per_compositor_data_[compositor];
   if (!data)
     data = CreatePerCompositorData(compositor);
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kUIEnableSoftwareCompositing)) {
     context_provider = ContextProviderCommandBuffer::Create(
-        base::Bind(&GpuProcessTransportFactory::CreateContextCommon,
-                   base::Unretained(this),
-                   data->swap_client->AsWeakPtr(),
-                   data->surface_id));
+        GpuProcessTransportFactory::CreateContextCommon(
+            data->swap_client->AsWeakPtr(),
+            data->surface_id));
   }
   if (!context_provider.get()) {
     if (ui::Compositor::WasInitializedWithThread()) {
       LOG(FATAL) << "Failed to create UI context, but can't use software "
                  " compositing with browser threaded compositing. Aborting.";
     }
 
     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface =
         SoftwareBrowserCompositorOutputSurface::Create(
             CreateSoftwareOutputDevice(compositor));
@@ skipping 143 matching lines @@
 void GpuProcessTransportFactory::RemoveObserver(
     ImageTransportFactoryObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::OffscreenContextProviderForMainThread() {
   if (!shared_contexts_main_thread_.get() ||
       shared_contexts_main_thread_->DestroyedOnMainThread()) {
     shared_contexts_main_thread_ = ContextProviderCommandBuffer::Create(
-        base::Bind(&GpuProcessTransportFactory::
-                       CreateOffscreenCommandBufferContext,
-                   base::Unretained(this)));
+        GpuProcessTransportFactory::CreateOffscreenCommandBufferContext());
     if (shared_contexts_main_thread_) {
       shared_contexts_main_thread_->SetLostContextCallback(base::Bind(
           &GpuProcessTransportFactory::
               OnLostMainThreadSharedContextInsideCallback,
           callback_factory_.GetWeakPtr()));
 
       if (!shared_contexts_main_thread_->BindToCurrentThread())
         shared_contexts_main_thread_ = NULL;
     }
   }
   return shared_contexts_main_thread_;
 }
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::OffscreenContextProviderForCompositorThread() {
   if (!shared_contexts_compositor_thread_.get() ||
       shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
     shared_contexts_compositor_thread_ = ContextProviderCommandBuffer::Create(
-        base::Bind(&GpuProcessTransportFactory::
-                       CreateOffscreenCommandBufferContext,
-                   base::Unretained(this)));
+        GpuProcessTransportFactory::CreateOffscreenCommandBufferContext());
   }
   return shared_contexts_compositor_thread_;
 }
 
 void GpuProcessTransportFactory::OnLostContext(ui::Compositor* compositor) {
   LOG(ERROR) << "Lost UI compositor context.";
   PerCompositorData* data = per_compositor_data_[compositor];
   DCHECK(data);
 
   // Prevent callbacks from other contexts in the same share group from
@@ skipping 78 matching lines @@
   shared_contexts_main_thread_ = NULL;
 
   scoped_ptr<GLHelper> old_helper(gl_helper_.release());
 
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 }
 
 }  // namespace content