Add gfx::SurfaceFactoryWebview

android_webview/browser/in_process_view_renderer.cc

 // Copyright 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 "android_webview/browser/in_process_view_renderer.h"
 
 #include <android/bitmap.h>
 
+#include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/common/aw_switches.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 134 matching lines @@
 }
 
 ScopedAllowGL::~ScopedAllowGL() {
   allow_gl = false;
 }
 
 bool ScopedAllowGL::allow_gl = false;
 
 base::LazyInstance<GLViewRendererManager>::Leaky g_view_renderer_manager;
 
+class ScopedSetSurfaceFactory {
+ public:
+  ScopedSetSurfaceFactory(InProcessViewRenderer* factory);
+  ~ScopedSetSurfaceFactory();
+};
+
+ScopedSetSurfaceFactory::ScopedSetSurfaceFactory(
+    InProcessViewRenderer* factory) {
+  DCHECK(factory);
+  DCHECK(!gfx::SurfaceFactoryAndroid::GetInstance());
+  gfx::SurfaceFactoryAndroid::SetInstance(factory);
+}
+
+ScopedSetSurfaceFactory::~ScopedSetSurfaceFactory() {
+  gfx::SurfaceFactoryAndroid::SetInstance(NULL);
+}
+
 }  // namespace
 
 // Called from different threads!
 static void ScheduleGpuWork() {
   if (ScopedAllowGL::IsAllowed()) {
     gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
   } else {
     InProcessViewRenderer* renderer = static_cast<InProcessViewRenderer*>(
         g_view_renderer_manager.Get().GetMostRecentlyDrawn());
     if (!renderer || !renderer->RequestProcessGL()) {
       LOG(ERROR) << "Failed to request DrawGL. Probably going to deadlock.";
     }
   }
 }
 
 // static
 void BrowserViewRenderer::SetAwDrawSWFunctionTable(
     AwDrawSWFunctionTable* table) {
   g_sw_draw_functions = table;
   g_is_skia_version_compatible =
       g_sw_draw_functions->is_skia_version_compatible(&SkGraphics::GetVersion);
   LOG_IF(WARNING, !g_is_skia_version_compatible)
       << "Skia versions are not compatible, rendering performance will suffer.";
 
   gpu::InProcessCommandBuffer::SetScheduleCallback(
       base::Bind(&ScheduleGpuWork));
+
+  DCHECK(!gfx::SurfaceFactoryAndroid::GetInstance());
 }
 
 // static
 AwDrawSWFunctionTable* BrowserViewRenderer::GetAwDrawSWFunctionTable() {
   return g_sw_draw_functions;
 }
 
 // static
 bool BrowserViewRenderer::IsSkiaVersionCompatible() {
   DCHECK(g_sw_draw_functions);
@@ skipping 83 matching lines @@
     return compositor_ && client_->RequestDrawGL(java_canvas);
   }
   // Perform a software draw
   block_invalidates_ = true;
   bool result = DrawSWInternal(java_canvas, clip);
   block_invalidates_ = false;
   EnsureContinuousInvalidation(NULL, false);
   return result;
 }
 
+scoped_refptr<gfx::GLSurface>
+InProcessViewRenderer::CreateNonOwnedViewSurface() {
+  DCHECK(!hardware_initialized_);
+  DCHECK(!gl_surface_);
+  gl_surface_ = new AwGLSurface;
+  return gl_surface_;
+}
+
+bool InProcessViewRenderer::InitializeHwDraw() {
+  TRACE_EVENT0("android_webview", "InitializeHwDraw");
+
+  {
+    ScopedSetSurfaceFactory setter(this);
+    hardware_failed_ = !compositor_->InitializeHwDraw();
+  }
+
+  hardware_initialized_ = true;
+  if (!hardware_failed_) {
+    DCHECK(gl_surface_);
+  }
+
+  return !hardware_failed_;
+}
+
 void InProcessViewRenderer::DrawGL(AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawGL");
   DCHECK(visible_);
 
   manager_key_ = g_view_renderer_manager.Get().DidDrawGL(manager_key_, this);
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   if (!current_context) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NullEGLContext", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW);
   gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
   ScopedAllowGL allow_gl;
 
   if (attached_to_window_ && compositor_ && !hardware_initialized_) {
-    TRACE_EVENT0("android_webview", "InitializeHwDraw");
-    hardware_failed_ = !compositor_->InitializeHwDraw();
-    hardware_initialized_ = true;
-    last_egl_context_ = current_context;
-
-    if (hardware_failed_)
+    if (InitializeHwDraw())
+      last_egl_context_ = current_context;
+    else
       return;
   }
 
   if (draw_info->mode == AwDrawGLInfo::kModeProcess)
     return;
 
   // DrawGL may be called without OnDraw, so cancel |fallback_tick_| here as
   // well just to be safe.
   fallback_tick_.Cancel();
 
   if (last_egl_context_ != current_context) {
     // TODO(boliu): Handle context lost
     TRACE_EVENT_INSTANT0(
         "android_webview", "EGLContextChanged", TRACE_EVENT_SCOPE_THREAD);
   }
-  last_egl_context_ = current_context;
 
   if (!compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
+  DCHECK(gl_surface_);
+  gl_surface_->SetBackingFrameBufferObject(
+      state_restore.framebuffer_binding_ext());
+
   gfx::Transform transform;
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(scroll_at_start_of_frame_.x(),
                       scroll_at_start_of_frame_.y());
-  // TODO(joth): Check return value.
-  block_invalidates_ = true;
   gfx::Rect clip_rect(draw_info->clip_left,
                       draw_info->clip_top,
                       draw_info->clip_right - draw_info->clip_left,
                       draw_info->clip_bottom - draw_info->clip_top);
+  block_invalidates_ = true;
+  // TODO(joth): Check return value.
   compositor_->DemandDrawHw(gfx::Size(draw_info->width, draw_info->height),
                             transform,
                             clip_rect,
                             state_restore.stencil_enabled());
   block_invalidates_ = false;
+  gl_surface_->ResetBackingFrameBufferObject();
 
   UpdateCachedGlobalVisibleRect();
   bool drew_full_visible_rect = clip_rect.Contains(cached_global_visible_rect_);
   EnsureContinuousInvalidation(draw_info, !drew_full_visible_rect);
 }
 
 void InProcessViewRenderer::SetGlobalVisibleRect(
     const gfx::Rect& visible_rect) {
   cached_global_visible_rect_ = visible_rect;
 }
@@ skipping 179 matching lines @@
   NoLongerExpectsDrawGL();
   if (hardware_initialized_) {
     DCHECK(compositor_);
 
     ScopedAppGLStateRestore state_restore(
         ScopedAppGLStateRestore::MODE_DETACH_FROM_WINDOW);
     gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
     ScopedAllowGL allow_gl;
     compositor_->ReleaseHwDraw();
     hardware_initialized_ = false;
+    gl_surface_ = NULL;
   }
 
   attached_to_window_ = false;
 }
 
 bool InProcessViewRenderer::IsAttachedToWindow() {
   return attached_to_window_;
 }
 
 bool InProcessViewRenderer::IsViewVisible() {
@@ skipping 211 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview