aw: Remove legacy rendering path

content/browser/android/in_process/synchronous_compositor_factory_impl.cc

 // Copyright 2014 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/android/in_process/synchronous_compositor_factory_impl.h"
 
 #include "content/browser/android/in_process/synchronous_compositor_output_surface.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "ui/gl/android/surface_texture.h"
@@ skipping 37 matching lines @@
                                       gfx::kNullAcceleratedWidget,
                                       gfx::Size(1, 1),
                                       NULL /* share_context */,
                                       false /* share_resources */,
                                       in_process_attribs,
                                       gpu_preference));
   return context.Pass();
 }
 
 scoped_ptr<gpu::GLInProcessContext> CreateContext(
-    scoped_refptr<gfx::GLSurface> surface,
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     gpu::GLInProcessContext* share_context) {
   const gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
   gpu::GLInProcessContextAttribs in_process_attribs;
   WebGraphicsContext3DInProcessCommandBufferImpl::ConvertAttributes(
       GetDefaultAttribs(), &in_process_attribs);
   in_process_attribs.lose_context_when_out_of_memory = 1;
 
-
-  bool is_offscreen = false;
-  gfx::Size size(1, 1);
-  if (surface) {
-    is_offscreen = surface->IsOffscreen();
-    size = surface->GetSize();
-  }
-
   scoped_ptr<gpu::GLInProcessContext> context(
       gpu::GLInProcessContext::Create(service,
-                                      surface,
-                                      is_offscreen,
+                                      NULL /* surface */,
+                                      false /* is_offscreen */,
                                       gfx::kNullAcceleratedWidget,
-                                      size,
+                                      gfx::Size(1, 1),
                                       share_context,
                                       false /* share_resources */,
                                       in_process_attribs,
                                       gpu_preference));
   return context.Pass();
 }
 
 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> WrapContext(
     scoped_ptr<gpu::GLInProcessContext> context) {
   if (!context.get())
@@ skipping 79 matching lines @@
              !offscreen_context_for_main_thread_->BindToCurrentThread();
   }
 
   if (failed) {
     offscreen_context_for_main_thread_ = NULL;
   }
   return offscreen_context_for_main_thread_;
 }
 
 scoped_refptr<cc::ContextProvider> SynchronousCompositorFactoryImpl::
-    CreateOnscreenContextProviderForCompositorThread(
-        scoped_refptr<gfx::GLSurface> surface) {
+    CreateOnscreenContextProviderForCompositorThread() {
   DCHECK(service_);
 
   if (!share_context_.get())
-    share_context_ = CreateContext(NULL, service_, NULL);
+    share_context_ = CreateContext(service_, NULL);
   return webkit::gpu::ContextProviderInProcess::Create(
-      WrapContext(CreateContext(surface, service_, share_context_.get())),
+      WrapContext(CreateContext(service_, share_context_.get())),
       "Child-Compositor");
 }
 
 gpu::GLInProcessContext* SynchronousCompositorFactoryImpl::GetShareContext() {
   DCHECK(share_context_.get());
   return share_context_.get();
 }
 
 scoped_refptr<StreamTextureFactory>
 SynchronousCompositorFactoryImpl::CreateStreamTextureFactory(int frame_id) {
@@ skipping 34 matching lines @@
       context_provider;
   // This check only guarantees the main thread context is created after
   // a compositor did successfully initialize hardware draw in the past.
   // In particular this does not guarantee that the main thread context
   // will fail creation when all compositors release hardware draw.
   if (CanCreateMainThreadContext() && !video_context_provider_) {
     DCHECK(service_);
     DCHECK(share_context_.get());
 
     video_context_provider_ = new VideoContextProvider(
-        CreateContext(NULL, service_, share_context_.get()));
+        CreateContext(service_, share_context_.get()));
   }
   return video_context_provider_;
 }
 
 void SynchronousCompositorFactoryImpl::SetDeferredGpuService(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service) {
   DCHECK(!service_);
   service_ = service;
 }
 
 }  // namespace content