[Android WebView] Implement Ubercomp for Render Thread support

android_webview/browser/hardware_renderer_legacy.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 "android_webview/browser/hardware_renderer.h"
+#include "android_webview/browser/hardware_renderer_legacy.h"
 
 #include "android_webview/browser/aw_gl_surface.h"
-#include "android_webview/browser/browser_view_renderer_client.h"
+#include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
+#include "cc/output/compositor_frame.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
-#include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace android_webview {
 
-HardwareRenderer::HardwareRenderer(SharedRendererState* state)
-    : shared_renderer_state_(state),
-      last_egl_context_(eglGetCurrentContext()) {
+HardwareRendererLegacy::HardwareRendererLegacy(SharedRendererState* state)
+    : shared_renderer_state_(state), last_egl_context_(eglGetCurrentContext()) {
   DCHECK(last_egl_context_);
 
   gl_surface_ = new AwGLSurface;
   bool success =
-      shared_renderer_state_->GetCompositor()->
-          InitializeHwDraw(gl_surface_);
+      shared_renderer_state_->GetCompositor()->InitializeHwDraw(gl_surface_);
   DCHECK(success);
 }
 
-HardwareRenderer::~HardwareRenderer() {
+HardwareRendererLegacy::~HardwareRendererLegacy() {
+  draw_gl_input_ = shared_renderer_state_->PassDrawGLInput();
   shared_renderer_state_->GetCompositor()->ReleaseHwDraw();
   gl_surface_ = NULL;
 }
 
-bool HardwareRenderer::DrawGL(bool stencil_enabled,
-                              int framebuffer_binding_ext,
-                              AwDrawGLInfo* draw_info,
-                              DrawGLResult* result) {
-  TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
+bool HardwareRendererLegacy::DrawGL(bool stencil_enabled,
+                                    int framebuffer_binding_ext,
+                                    AwDrawGLInfo* draw_info,
+                                    DrawGLResult* result) {
+  TRACE_EVENT0("android_webview", "HardwareRendererLegacy::DrawGL");
 
   // 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) {
     DLOG(ERROR) << "DrawGL called without EGLContext";
     return false;
   }
 
   // TODO(boliu): Handle context loss.
   if (last_egl_context_ != current_context)
     DLOG(WARNING) << "EGLContextChanged";
 
-  if (draw_info->mode != AwDrawGLInfo::kModeDraw)
-    return false;
-
   // Should only need to access SharedRendererState in kModeDraw and kModeSync.
-  const DrawGLInput input = shared_renderer_state_->GetDrawGLInput();
+  scoped_ptr<DrawGLInput> input = shared_renderer_state_->PassDrawGLInput();
+  if (input.get())
+    draw_gl_input_ = input.Pass();
   SetCompositorMemoryPolicy();
 
   gl_surface_->SetBackingFrameBufferObject(framebuffer_binding_ext);
 
   gfx::Transform transform;
   transform.matrix().setColMajorf(draw_info->transform);
-  transform.Translate(input.scroll_offset.x(), input.scroll_offset.y());
+  transform.Translate(draw_gl_input_->scroll_offset.x(),
+                      draw_gl_input_->scroll_offset.y());
   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);
 
   gfx::Rect viewport(draw_info->width, draw_info->height);
   if (!draw_info->is_layer) {
-    gfx::RectF view_rect(input.width, input.height);
+    gfx::RectF view_rect(draw_gl_input_->width, draw_gl_input_->height);
     transform.TransformRect(&view_rect);
     viewport.Intersect(gfx::ToEnclosingRect(view_rect));
   }
 
-  bool did_draw = shared_renderer_state_->GetCompositor()->DemandDrawHw(
-      gfx::Size(draw_info->width, draw_info->height),
-      transform,
-      viewport,
-      clip_rect,
-      stencil_enabled);
+  scoped_ptr<cc::CompositorFrame> frame =
+      shared_renderer_state_->GetCompositor()->DemandDrawHw(
+          gfx::Size(draw_info->width, draw_info->height),
+          transform,
+          viewport,
+          clip_rect,
+          framebuffer_binding_ext);
   gl_surface_->ResetBackingFrameBufferObject();
 
-  if (did_draw) {
-    result->frame_id = input.frame_id;
+  if (frame.get()) {
     result->clip_contains_visible_rect =
-        clip_rect.Contains(input.global_visible_rect);
+        clip_rect.Contains(draw_gl_input_->global_visible_rect);
   }
-  return did_draw;
+  return !!frame.get();
 }
 
-void HardwareRenderer::SetCompositorMemoryPolicy() {
+void HardwareRendererLegacy::SetCompositorMemoryPolicy() {
   if (shared_renderer_state_->IsMemoryPolicyDirty()) {
     content::SynchronousCompositorMemoryPolicy policy =
         shared_renderer_state_->GetMemoryPolicy();
     // Memory policy is set by BrowserViewRenderer on UI thread.
     shared_renderer_state_->GetCompositor()->SetMemoryPolicy(policy);
     shared_renderer_state_->SetMemoryPolicyDirty(false);
   }
 }
 
 }  // namespace android_webview