aw: Remove legacy rendering path

android_webview/browser/browser_view_renderer.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/browser_view_renderer.h"
 
 #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"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #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"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 using base::android::AttachCurrentThread;
@@ skipping 88 matching lines @@
     BrowserViewRendererClient* client,
     SharedRendererState* shared_renderer_state,
     content::WebContents* web_contents,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
     : client_(client),
       shared_renderer_state_(shared_renderer_state),
       web_contents_(web_contents),
       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),
       attached_to_window_(false),
       hardware_enabled_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
       clear_view_(false),
       compositor_needs_continuous_invalidate_(false),
       block_invalidates_(false),
       width_(0),
       height_(0),
       num_tiles_(0u),
       num_bytes_(0u) {
   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() {
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, NULL);
   // OnDetachedFromWindow should be called before the destructor, so the memory
   // policy should have already been updated.
 }
 
 // This function updates the cached memory policy in shared renderer state, as
 // well as the tile resource allocation in GlobalTileManager.
@@ skipping 12 matching lines @@
   if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN)
     return;
 
   // Do not release resources on view we expect to get DrawGL soon.
   if (level < TRIM_MEMORY_BACKGROUND && visible)
     return;
 
   // 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");
 
   RequestMemoryPolicy(zero_policy);
   EnforceMemoryPolicyImmediately(zero_policy);
 }
 
 SynchronousCompositorMemoryPolicy
 BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
@@ skipping 25 matching lines @@
   // The following line will call BrowserViewRenderer::SetTilesNum().
   manager->RequestTiles(new_policy.num_resources_limit, tile_manager_key_);
 }
 
 void BrowserViewRenderer::SetNumTiles(size_t num_tiles,
                                       bool effective_immediately) {
   if (num_tiles == 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,
                                  bool is_hardware_canvas,
                                  const gfx::Vector2d& scroll,
                                  const gfx::Rect& global_visible_rect,
                                  const gfx::Rect& clip) {
   last_on_draw_scroll_offset_ = scroll;
   last_on_draw_global_visible_rect_ = global_visible_rect;
 
   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);
     }
   }
   if (!hardware_enabled_)
     return false;
 
   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_;
 
   gfx::Transform transform;
   gfx::Size surface_size(width_, height_);
   gfx::Rect viewport(surface_size);
   // TODO(boliu): Should really be |last_on_draw_global_visible_rect_|.
   // 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;
 
   GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
 
   frame->AssignTo(&draw_gl_input->frame);
   scoped_ptr<DrawGLInput> old_input = shared_renderer_state_->PassDrawGLInput();
   if (old_input.get()) {
     shared_renderer_state_->ReturnResources(
         old_input->frame.delegated_frame_data->resource_list);
   }
   shared_renderer_state_->SetDrawGLInput(draw_gl_input.Pass());
 
   DidComposite(false);
   bool did_request = client_->RequestDrawGL(java_canvas, false);
   if (did_request)
     return true;
 
   ReturnResources();
   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();
 }
 
 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);
   }
 }
 
 bool BrowserViewRenderer::DrawSWInternal(jobject java_canvas,
                                          const gfx::Rect& clip) {
   if (clip.IsEmpty()) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_EmptyClip", TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
-  if (!has_compositor_) {
+  if (!compositor_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   return BrowserViewRendererJavaHelper::GetInstance()
       ->RenderViaAuxilaryBitmapIfNeeded(
             java_canvas,
             last_on_draw_scroll_offset_,
             clip,
@@ skipping 10 matching lines @@
     return skia::AdoptRef(new SkPicture);
   }
 
   // Reset scroll back to the origin, will go back to the old
   // value when scroll_reset is out of scope.
   AutoResetWithLock scroll_reset(
       &scroll_offset_dip_, gfx::Vector2dF(), render_thread_lock_);
 
   SkPictureRecorder recorder;
   SkCanvas* rec_canvas = recorder.beginRecording(width, height, NULL, 0);
-  if (has_compositor_)
+  if (compositor_)
     CompositeSW(rec_canvas);
   return skia::AdoptRef(recorder.endRecording());
 }
 
 void BrowserViewRenderer::EnableOnNewPicture(bool enabled) {
   on_new_picture_enable_ = enabled;
 }
 
 void BrowserViewRenderer::ClearView() {
   TRACE_EVENT_INSTANT0("android_webview",
@@ skipping 66 matching lines @@
   attached_to_window_ = false;
   if (hardware_enabled_) {
     scoped_ptr<DrawGLInput> input = shared_renderer_state_->PassDrawGLInput();
     if (input.get()) {
       shared_renderer_state_->ReturnResources(
           input->frame.delegated_frame_data->resource_list);
     }
     ReturnResources();
     DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());
 
-    if (switches::UbercompEnabled())
-      shared_renderer_state_->GetCompositor()->ReleaseHwDraw();
+    compositor_->ReleaseHwDraw();
     shared_renderer_state_->SetSharedContext(NULL);
     hardware_enabled_ = false;
   }
   SynchronousCompositorMemoryPolicy zero_policy;
   RequestMemoryPolicy(zero_policy);
   GlobalTileManager::GetInstance()->Remove(tile_manager_key_);
   // The hardware resources are released in the destructor of hardware renderer,
   // so we don't need to do it here.
   // See AwContents::ReleaseHardwareDrawOnRenderThread(JNIEnv*, jobject).
 }
 
 bool BrowserViewRenderer::IsAttachedToWindow() const {
   return attached_to_window_;
 }
 
 bool BrowserViewRenderer::IsVisible() const {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
 }
 
 gfx::Rect BrowserViewRenderer::GetScreenRect() const {
   return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_));
 }
 
 void BrowserViewRenderer::DidInitializeCompositor(
     content::SynchronousCompositor* compositor) {
   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) {
   {
     base::AutoLock lock(render_thread_lock_);
     if (compositor_needs_continuous_invalidate_ == invalidate)
       return;
 
     TRACE_EVENT_INSTANT1("android_webview",
                          "BrowserViewRenderer::SetContinuousInvalidate",
@@ skipping 55 matching lines @@
   }
 
   TRACE_EVENT_INSTANT2("android_webview",
                "BrowserViewRenderer::ScrollTo",
                TRACE_EVENT_SCOPE_THREAD,
                "x",
                scroll_offset_dip.x(),
                "y",
                scroll_offset_dip.y());
 
-  if (has_compositor_)
-    shared_renderer_state_->GetCompositor()->
-        DidChangeRootLayerScrollOffset();
+  if (compositor_)
+    compositor_->DidChangeRootLayerScrollOffset();
 }
 
 void BrowserViewRenderer::DidUpdateContent() {
   if (!ui_task_runner_->BelongsToCurrentThread()) {
     ui_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&BrowserViewRenderer::DidUpdateContent,
                                          ui_thread_weak_ptr_));
     return;
   }
   TRACE_EVENT_INSTANT0("android_webview",
@@ skipping 187 matching lines @@
 
 void BrowserViewRenderer::FallbackTickFired() {
   TRACE_EVENT1("android_webview",
                "BrowserViewRenderer::FallbackTickFired",
                "compositor_needs_continuous_invalidate_",
                compositor_needs_continuous_invalidate_);
 
   // 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);
   SkCanvas canvas(bitmap);
   CompositeSW(&canvas);
 }
 
 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;
 }
 
 void BrowserViewRenderer::DidComposite(bool force_invalidate) {
   {
     base::AutoLock lock(render_thread_lock_);
     block_invalidates_ = false;
   }
 
@@ skipping 44 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