Remove GLInProcessContext::CreateContext()

gpu/command_buffer/client/gl_in_process_context.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 "gpu/command_buffer/client/gl_in_process_context.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 38 matching lines @@
       public base::SupportsWeakPtr<GLInProcessContextImpl> {
  public:
   explicit GLInProcessContextImpl();
   virtual ~GLInProcessContextImpl();
 
   bool Initialize(
       scoped_refptr<gfx::GLSurface> surface,
       bool is_offscreen,
       bool use_global_share_group,
       GLInProcessContext* share_context,
-      gfx::AcceleratedWidget window,
       const gfx::Size& size,
       const GLInProcessContextAttribs& attribs,
       gfx::GpuPreference gpu_preference,
       const scoped_refptr<InProcessCommandBuffer::Service>& service);
 
   // GLInProcessContext implementation:
   virtual void SetContextLostCallback(const base::Closure& callback) OVERRIDE;
   virtual gles2::GLES2Implementation* GetImplementation() OVERRIDE;
 
 #if defined(OS_ANDROID)
@@ skipping 47 matching lines @@
   if (!context_lost_callback_.is_null()) {
     context_lost_callback_.Run();
   }
 }
 
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     bool use_global_share_group,
     GLInProcessContext* share_context,
-    gfx::AcceleratedWidget window,

[boliu, 2014/07/31 02:27:22]

I don't think you compiled this for android.
synchronous_compositor_factory_impl.cc needs this

[hj.r.chung, 2014/07/31 02:30:33]

I removed it because synchronous_compositor_factory_impl was just passing
kNullAcceleratedWidget but if you think we should keep this
I'll add it back

     const gfx::Size& size,
     const GLInProcessContextAttribs& attribs,
     gfx::GpuPreference gpu_preference,
     const scoped_refptr<InProcessCommandBuffer::Service>& service) {
   DCHECK(!use_global_share_group || !share_context);
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   // Changes to these values should also be copied to
   // gpu/command_buffer/client/gl_in_process_context.cc and to
   // content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h
@@ skipping 81 matching lines @@
     GLInProcessContextImpl* impl =
         static_cast<GLInProcessContextImpl*>(share_context);
     share_group = impl->gles2_implementation_->share_group();
     share_command_buffer = impl->command_buffer_.get();
     DCHECK(share_group);
     DCHECK(share_command_buffer);
   }
 
   if (!command_buffer_->Initialize(surface,
                                    is_offscreen,
-                                   window,
+                                   gfx::kNullAcceleratedWidget,

[boliu, 2014/07/31 02:35:32]

You can clean up in in_process_command_buffer as well.

[hj.r.chung, 2014/07/31 08:35:35]

sorry for the confusion, window is still needed 

                                    size,
                                    attrib_vector,
                                    gpu_preference,
                                    wrapped_callback,
                                    share_command_buffer)) {
     LOG(ERROR) << "Failed to initialize InProcessCommmandBuffer";
     return false;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
@@ skipping 65 matching lines @@
       blue_size(-1),
       green_size(-1),
       red_size(-1),
       depth_size(-1),
       stencil_size(-1),
       samples(-1),
       sample_buffers(-1),
       fail_if_major_perf_caveat(-1),
       lose_context_when_out_of_memory(-1) {}
 
-// static
-GLInProcessContext* GLInProcessContext::CreateContext(
-    bool is_offscreen,
-    gfx::AcceleratedWidget window,
-    const gfx::Size& size,
-    bool share_resources,
-    const GLInProcessContextAttribs& attribs,
-    gfx::GpuPreference gpu_preference) {
-  scoped_ptr<GLInProcessContextImpl> context(
-      new GLInProcessContextImpl());
-  if (!context->Initialize(
-      NULL /* surface */,
-      is_offscreen,
-      share_resources,
-      NULL,
-      window,
-      size,
-      attribs,
-      gpu_preference,
-      scoped_refptr<InProcessCommandBuffer::Service>()))
-    return NULL;
-
-  return context.release();
-}
-
 GLInProcessContext* GLInProcessContext::Create(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
-    gfx::AcceleratedWidget window,
     const gfx::Size& size,
     GLInProcessContext* share_context,
     bool use_global_share_group,
     const GLInProcessContextAttribs& attribs,
     gfx::GpuPreference gpu_preference) {
   DCHECK(!use_global_share_group || !share_context);
   if (surface.get()) {
     DCHECK_EQ(surface->IsOffscreen(), is_offscreen);
     DCHECK(surface->GetSize() == size);
-    DCHECK_EQ(gfx::kNullAcceleratedWidget, window);
   }
 
   scoped_ptr<GLInProcessContextImpl> context(new GLInProcessContextImpl());
   if (!context->Initialize(surface,
                            is_offscreen,
                            use_global_share_group,
                            share_context,
-                           gfx::kNullAcceleratedWidget,
                            size,
                            attribs,
                            gpu_preference,
                            service))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu