aw: Remove legacy rendering path

android_webview/browser/browser_view_renderer.cc

Index: android_webview/browser/browser_view_renderer.cc
diff --git a/android_webview/browser/browser_view_renderer.cc b/android_webview/browser/browser_view_renderer.cc
index 3c1ceb42be1d1764d60340660eea313ab09ef9aa..4377b605b78ecb2ff5d9a1a42a8c791ff0748a0f 100644
--- a/android_webview/browser/browser_view_renderer.cc
+++ b/android_webview/browser/browser_view_renderer.cc
@@ -6,7 +6,6 @@
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/shared_renderer_state.h"
-#include "android_webview/common/aw_switches.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
@@ -17,7 +16,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/compositor_frame.h"
-#include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
@@ -126,7 +124,7 @@ BrowserViewRenderer::BrowserViewRenderer(
       weak_factory_on_ui_thread_(this),
       ui_thread_weak_ptr_(weak_factory_on_ui_thread_.GetWeakPtr()),
       ui_task_runner_(ui_task_runner),
-      has_compositor_(false),
+      compositor_(NULL),
       is_paused_(false),
       view_visible_(false),
       window_visible_(false),
@@ -145,8 +143,8 @@ BrowserViewRenderer::BrowserViewRenderer(
   CHECK(web_contents_);
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, this);
 
-  // Currently the logic in this class relies on |has_compositor_| remaining
-  // false until the DidInitializeCompositor() call, hence it is not set here.
+  // Currently the logic in this class relies on |compositor_| remaining
+  // NULL until the DidInitializeCompositor() call, hence it is not set here.
 }
 
 BrowserViewRenderer::~BrowserViewRenderer() {
@@ -179,7 +177,7 @@ void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
   // Just set the memory limit to 0 and drop all tiles. This will be reset to
   // normal levels in the next DrawGL call.
   SynchronousCompositorMemoryPolicy zero_policy;
-  if (shared_renderer_state_->GetMemoryPolicy() == zero_policy)
+  if (memory_policy_ == zero_policy)
     return;
 
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory");
@@ -225,24 +223,21 @@ void BrowserViewRenderer::SetNumTiles(size_t num_tiles,
     return;
   num_tiles_ = num_tiles;
 
-  SynchronousCompositorMemoryPolicy new_policy;
-  new_policy.num_resources_limit = num_tiles_;
-  new_policy.bytes_limit = num_bytes_;
-  shared_renderer_state_->SetMemoryPolicy(new_policy);
+  memory_policy_.num_resources_limit = num_tiles_;
+  memory_policy_.bytes_limit = num_bytes_;
 
   if (effective_immediately)
-    EnforceMemoryPolicyImmediately(new_policy);
+    EnforceMemoryPolicyImmediately(memory_policy_);
 }
 
 void BrowserViewRenderer::EnforceMemoryPolicyImmediately(
     SynchronousCompositorMemoryPolicy new_policy) {
-  shared_renderer_state_->GetCompositor()->SetMemoryPolicy(new_policy);
+  compositor_->SetMemoryPolicy(new_policy);
   ForceFakeCompositeSW();
-  shared_renderer_state_->SetMemoryPolicyDirty(false);
 }
 
 size_t BrowserViewRenderer::GetNumTiles() const {
-  return shared_renderer_state_->GetMemoryPolicy().num_resources_limit;
+  return memory_policy_.num_resources_limit;
 }
 
 bool BrowserViewRenderer::OnDraw(jobject java_canvas,
@@ -256,57 +251,20 @@ bool BrowserViewRenderer::OnDraw(jobject java_canvas,
   if (clear_view_)
     return false;
 
-  if (is_hardware_canvas && attached_to_window_) {
-    if (switches::UbercompEnabled()) {
-      return OnDrawHardware(java_canvas);
-    } else {
-      return OnDrawHardwareLegacy(java_canvas);
-    }
-  }
+  if (is_hardware_canvas && attached_to_window_)
+    return OnDrawHardware(java_canvas);
   // Perform a software draw
   return DrawSWInternal(java_canvas, clip);
 }
 
-bool BrowserViewRenderer::OnDrawHardwareLegacy(jobject java_canvas) {
-  scoped_ptr<DrawGLInput> draw_gl_input(new DrawGLInput);
-  draw_gl_input->scroll_offset = last_on_draw_scroll_offset_;
-  draw_gl_input->global_visible_rect = last_on_draw_global_visible_rect_;
-  draw_gl_input->width = width_;
-  draw_gl_input->height = height_;
-
-  SynchronousCompositorMemoryPolicy old_policy =
-      shared_renderer_state_->GetMemoryPolicy();
-  SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
-  RequestMemoryPolicy(new_policy);
-  // We should be performing a hardware draw here. If we don't have the
-  // compositor yet or if RequestDrawGL fails, it means we failed this draw
-  // and thus return false here to clear to background color for this draw.
-  bool did_draw_gl =
-      has_compositor_ && client_->RequestDrawGL(java_canvas, false);
-  if (did_draw_gl) {
-    GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
-    shared_renderer_state_->SetDrawGLInput(draw_gl_input.Pass());
-  } else {
-    RequestMemoryPolicy(old_policy);
-  }
-
-  return did_draw_gl;
-}
-
-void BrowserViewRenderer::DidDrawGL(scoped_ptr<DrawGLResult> result) {
-  DidComposite(!result->clip_contains_visible_rect);

[hush (inactive), 2014/06/16 21:41:50]

after you delete this line, DidComposite will always be called with "false".

what are the circumstances that you force invalidation?

[boliu, 2014/06/16 22:43:27]

Good catch. Removed the arg to DidComposite

Force means we don't care if the compositor wants to invalidate, we invalidate
anyway. After this, it's only used for ClearView.

-}
-
 bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
-  if (!has_compositor_)
+  if (!compositor_)
     return false;
 
   if (!hardware_enabled_) {
-    hardware_enabled_ =
-        shared_renderer_state_->GetCompositor()->InitializeHwDraw(NULL);
+    hardware_enabled_ = compositor_->InitializeHwDraw(NULL);

[hush (inactive), 2014/06/16 21:41:50]

what does it mean to initialize hw draw with a NULL GLSurface?

[boliu, 2014/06/16 22:43:27]

Good catch again, removed the GLSurface path.

Normally creating a context (client side) will create its own GLSurface on the
service side. Webview had to punch throw all the layers to insert our own
GLSurface due to our own requirement, but that's no longer needed, at least the
bits through SyncCompositor bit.

The context in HardwareRenderer still uses it, but it creates the context
directly now.

     if (hardware_enabled_) {
-      gpu::GLInProcessContext* share_context =
-          shared_renderer_state_->GetCompositor()->GetShareContext();
+      gpu::GLInProcessContext* share_context = compositor_->GetShareContext();
       DCHECK(share_context);
       shared_renderer_state_->SetSharedContext(share_context);
     }
@@ -317,12 +275,10 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
   ReturnResources();
   SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
   RequestMemoryPolicy(new_policy);
-  shared_renderer_state_->GetCompositor()->SetMemoryPolicy(
-      shared_renderer_state_->GetMemoryPolicy());
+  compositor_->SetMemoryPolicy(memory_policy_);
 
   scoped_ptr<DrawGLInput> draw_gl_input(new DrawGLInput);
   draw_gl_input->scroll_offset = last_on_draw_scroll_offset_;
-  draw_gl_input->global_visible_rect = last_on_draw_global_visible_rect_;
   draw_gl_input->width = width_;
   draw_gl_input->height = height_;
 
@@ -333,9 +289,8 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
   // See crbug.com/372073.
   gfx::Rect clip = viewport;
   bool stencil_enabled = false;
-  scoped_ptr<cc::CompositorFrame> frame =
-      shared_renderer_state_->GetCompositor()->DemandDrawHw(
-          surface_size, transform, viewport, clip, stencil_enabled);
+  scoped_ptr<cc::CompositorFrame> frame = compositor_->DemandDrawHw(
+      surface_size, transform, viewport, clip, stencil_enabled);
   if (!frame.get())
     return false;
 
@@ -358,13 +313,12 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
   return false;
 }
 
-void BrowserViewRenderer::DidDrawDelegated(scoped_ptr<DrawGLResult> result) {
+void BrowserViewRenderer::DidDrawDelegated() {
   if (!ui_task_runner_->BelongsToCurrentThread()) {
     // TODO(boliu): This should be a cancelable callback.
     ui_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&BrowserViewRenderer::DidDrawDelegated,
-                                         ui_thread_weak_ptr_,
-                                         base::Passed(&result)));
+                                         ui_thread_weak_ptr_));
     return;
   }
   ReturnResources();
@@ -374,7 +328,7 @@ void BrowserViewRenderer::ReturnResources() {
   cc::CompositorFrameAck frame_ack;
   shared_renderer_state_->SwapReturnedResources(&frame_ack.resources);
   if (!frame_ack.resources.empty()) {
-    shared_renderer_state_->GetCompositor()->ReturnResources(frame_ack);
+    compositor_->ReturnResources(frame_ack);
   }
 }
 
@@ -386,7 +340,7 @@ bool BrowserViewRenderer::DrawSWInternal(jobject java_canvas,
     return true;
   }
 
-  if (!has_compositor_) {
+  if (!compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return false;
@@ -417,7 +371,7 @@ skia::RefPtr<SkPicture> BrowserViewRenderer::CapturePicture(int width,
 
   SkPictureRecorder recorder;
   SkCanvas* rec_canvas = recorder.beginRecording(width, height, NULL, 0);
-  if (has_compositor_)
+  if (compositor_)
     CompositeSW(rec_canvas);
   return skia::AdoptRef(recorder.endRecording());
 }
@@ -504,8 +458,7 @@ void BrowserViewRenderer::OnDetachedFromWindow() {
     ReturnResources();
     DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());
 
-    if (switches::UbercompEnabled())
-      shared_renderer_state_->GetCompositor()->ReleaseHwDraw();
+    compositor_->ReleaseHwDraw();
     shared_renderer_state_->SetSharedContext(NULL);
     hardware_enabled_ = false;
   }
@@ -535,21 +488,19 @@ void BrowserViewRenderer::DidInitializeCompositor(
   TRACE_EVENT0("android_webview",
                "BrowserViewRenderer::DidInitializeCompositor");
   DCHECK(compositor);
-  DCHECK(!has_compositor_);
+  DCHECK(!compositor_);
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  has_compositor_ = true;
-  shared_renderer_state_->SetCompositorOnUiThread(compositor);
+  compositor_ = compositor;
 }
 
 void BrowserViewRenderer::DidDestroyCompositor(
     content::SynchronousCompositor* compositor) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::DidDestroyCompositor");
-  DCHECK(has_compositor_);
+  DCHECK(compositor_);
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  has_compositor_ = false;
-  shared_renderer_state_->SetCompositorOnUiThread(NULL);
+  compositor_ = NULL;
   SynchronousCompositorMemoryPolicy zero_policy;
-  DCHECK(shared_renderer_state_->GetMemoryPolicy() == zero_policy);
+  DCHECK(memory_policy_ == zero_policy);
 }
 
 void BrowserViewRenderer::SetContinuousInvalidate(bool invalidate) {
@@ -625,9 +576,8 @@ void BrowserViewRenderer::ScrollTo(gfx::Vector2d scroll_offset) {
                "y",
                scroll_offset_dip.y());
 
-  if (has_compositor_)
-    shared_renderer_state_->GetCompositor()->
-        DidChangeRootLayerScrollOffset();
+  if (compositor_)
+    compositor_->DidChangeRootLayerScrollOffset();
 }
 
 void BrowserViewRenderer::DidUpdateContent() {
@@ -835,12 +785,12 @@ void BrowserViewRenderer::FallbackTickFired() {
   // This should only be called if OnDraw or DrawGL did not come in time, which
   // means block_invalidates_ must still be true.
   DCHECK(block_invalidates_);
-  if (compositor_needs_continuous_invalidate_ && has_compositor_)
+  if (compositor_needs_continuous_invalidate_ && compositor_)
     ForceFakeCompositeSW();
 }
 
 void BrowserViewRenderer::ForceFakeCompositeSW() {
-  DCHECK(has_compositor_);
+  DCHECK(compositor_);
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(0);
@@ -849,9 +799,8 @@ void BrowserViewRenderer::ForceFakeCompositeSW() {
 }
 
 bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
-  DCHECK(has_compositor_);
-  bool result = shared_renderer_state_->GetCompositor()->
-      DemandDrawSw(canvas);
+  DCHECK(compositor_);
+  bool result = compositor_->DemandDrawSw(canvas);
   DidComposite(false);
   return result;
 }