Part 1: Refactor Android WebView graphics code

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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event_argument.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/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/gpu_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 content::SynchronousCompositorMemoryPolicy;
@@ skipping 34 matching lines @@
     g_memory_override_in_bytes *= 1024 * 1024;
   }
 
   // There is no need to limit number of tiles, so use an effectively unlimited
   // value as the limit.
   GlobalTileManager::GetInstance()->SetTileLimit(10 * 1000 * 1000);
 }
 
 BrowserViewRenderer::BrowserViewRenderer(
     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),
+      shared_renderer_state_(
+          content::BrowserThread::GetMessageLoopProxyForThread(

[boliu, 2014/10/24 22:12:01]

pass in ui_task_runner

[hush (inactive), 2014/10/24 22:30:15]

SRS needs a base::MessageLoopProxy, which is a child class of
base::SingleThreadTaskRunner.

To do so, I will update SRS constructor to take const
scoped_refptr<base::SingleThreadTaskRunner>&

+              content::BrowserThread::UI),
+          this),
       web_contents_(web_contents),
       ui_task_runner_(ui_task_runner),
       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),
@@ skipping 11 matching lines @@
   // 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.
 }
 
+SharedRendererState* BrowserViewRenderer::GetSharedRendererState() {
+  return &shared_renderer_state_;
+}
+
+bool BrowserViewRenderer::RequestDrawGL(jobject canvas,
+                                        bool wait_for_completion) {
+  return client_->RequestDrawGL(canvas, wait_for_completion);
+}
+
 // This function updates the resource allocation in GlobalTileManager.
 void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   // Constants from Android ComponentCallbacks2.
   enum {
     TRIM_MEMORY_RUNNING_LOW = 10,
     TRIM_MEMORY_UI_HIDDEN = 20,
     TRIM_MEMORY_BACKGROUND = 40,
   };
 
@@ skipping 88 matching lines @@
 
   // Perform a software draw
   return OnDrawSoftware(java_canvas);
 }
 
 bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDrawHardware");
   if (!compositor_)
     return false;
 
-  shared_renderer_state_->SetScrollOffset(last_on_draw_scroll_offset_);
+  shared_renderer_state_.SetScrollOffsetOnUI(last_on_draw_scroll_offset_);
 
   if (!hardware_enabled_) {
     hardware_enabled_ = compositor_->InitializeHwDraw();
     if (hardware_enabled_) {
       tile_manager_key_ = GlobalTileManager::GetInstance()->PushBack(this);
     }
   }
   if (!hardware_enabled_)
     return false;
 
   if (last_on_draw_global_visible_rect_.IsEmpty() &&
       parent_draw_constraints_.surface_rect.IsEmpty()) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_EmptyVisibleRect",
                          TRACE_EVENT_SCOPE_THREAD);
-    shared_renderer_state_->SetForceInvalidateOnNextDrawGL(true);
+    shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(true);
     return client_->RequestDrawGL(java_canvas, false);
   }
 
   ReturnResourceFromParent();
-  if (shared_renderer_state_->HasCompositorFrame()) {
+  if (shared_renderer_state_.HasCompositorFrameOnUI()) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_PreviousFrameUnconsumed",
                          TRACE_EVENT_SCOPE_THREAD);
     DidSkipCompositeInDraw();
     return client_->RequestDrawGL(java_canvas, false);
   }
 
   scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
   if (!frame.get())
     return false;
 
-  shared_renderer_state_->SetCompositorFrame(frame.Pass(), false);
+  shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), false);
   GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
   return client_->RequestDrawGL(java_canvas, false);
 }
 
 scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
   SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
   RequestMemoryPolicy(new_policy);
   compositor_->SetMemoryPolicy(memory_policy_);
 
-  parent_draw_constraints_ = shared_renderer_state_->ParentDrawConstraints();
+  parent_draw_constraints_ =
+      shared_renderer_state_.GetParentDrawConstraintsOnUI();
   gfx::Size surface_size(width_, height_);
   gfx::Rect viewport(surface_size);
   gfx::Rect clip = viewport;
   gfx::Transform transform_for_tile_priority =
       parent_draw_constraints_.transform;
 
   // If the WebView is on a layer, WebView does not know what transform is
   // applied onto the layer so global visible rect does not make sense here.
   // In this case, just use the surface rect for tiling.
   gfx::Rect viewport_rect_for_tile_priority;
@@ skipping 13 matching lines @@
                                 transform_for_tile_priority);
   if (frame.get())
     DidComposite();
   return frame.Pass();
 }
 
 void BrowserViewRenderer::UpdateParentDrawConstraints() {
   // Post an invalidate if the parent draw constraints are stale and there is
   // no pending invalidate.
   bool needs_force_invalidate =
-      shared_renderer_state_->NeedsForceInvalidateOnNextDrawGL();
+      shared_renderer_state_.NeedsForceInvalidateOnNextDrawGLOnUI();
   if (needs_force_invalidate ||
       !parent_draw_constraints_.Equals(
-          shared_renderer_state_->ParentDrawConstraints())) {
-    shared_renderer_state_->SetForceInvalidateOnNextDrawGL(false);
+          shared_renderer_state_.GetParentDrawConstraintsOnUI())) {
+    shared_renderer_state_.SetForceInvalidateOnNextDrawGLOnUI(false);
     EnsureContinuousInvalidation(true, needs_force_invalidate);
   }
 }
 
 void BrowserViewRenderer::ReturnUnusedResource(
     scoped_ptr<cc::CompositorFrame> frame) {
   if (!frame.get())
     return;
 
   cc::CompositorFrameAck frame_ack;
   cc::TransferableResource::ReturnResources(
       frame->delegated_frame_data->resource_list, &frame_ack.resources);
   if (compositor_ && !frame_ack.resources.empty())
     compositor_->ReturnResources(frame_ack);
 }
 
 void BrowserViewRenderer::ReturnResourceFromParent() {
   cc::CompositorFrameAck frame_ack;
-  shared_renderer_state_->SwapReturnedResources(&frame_ack.resources);
+  shared_renderer_state_.SwapReturnedResourcesOnUI(&frame_ack.resources);
   if (compositor_ && !frame_ack.resources.empty()) {
     compositor_->ReturnResources(frame_ack);
   }
 }
 
 void BrowserViewRenderer::DidSkipCommitFrame() {
   // Treat it the same way as skipping onDraw.
   DidSkipCompositeInDraw();
 }
 
@@ skipping 112 matching lines @@
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   attached_to_window_ = false;
   DCHECK(!hardware_enabled_);
 }
 
 void BrowserViewRenderer::ReleaseHardware() {
   DCHECK(hardware_enabled_);
-  ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
+  // TODO(hush): do this in somewhere else. Either in hardware render or in
+  // shared renderer state.
+  ReturnUnusedResource(shared_renderer_state_.PassCompositorFrame());
   ReturnResourceFromParent();
-  DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());

[hush (inactive), 2014/10/24 21:37:41]

We don't need this because we have an equivalent DCHECK here:
https://code.google.com/p/chromium/codesearch#chromium/src/android_webview/br...

[boliu, 2014/10/24 22:12:01]

Keep this for now.

It's not quite the same. What if we decide to rewrite ReturnResourceFromParent
or something in the future.

[hush (inactive), 2014/10/24 22:30:15]

ok

 
   if (compositor_) {
     compositor_->ReleaseHwDraw();
     SynchronousCompositorMemoryPolicy zero_policy;
     RequestMemoryPolicy(zero_policy);
   }
 
   hardware_enabled_ = false;
   GlobalTileManager::GetInstance()->Remove(tile_manager_key_);
 }
@@ skipping 276 matching lines @@
                "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_);
   fallback_tick_pending_ = false;
   if (compositor_needs_continuous_invalidate_ && compositor_) {
     if (hardware_enabled_) {
       ReturnResourceFromParent();
-      ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
+      ReturnUnusedResource(shared_renderer_state_.PassCompositorFrame());
       scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
       if (frame.get()) {
-        shared_renderer_state_->SetCompositorFrame(frame.Pass(), true);
+        shared_renderer_state_.SetCompositorFrameOnUI(frame.Pass(), true);
       }
     } else {
       ForceFakeCompositeSW();
     }
   } else {
     // Pretend we just composited to unblock further invalidates.
     DidComposite();
   }
 }
 
@@ skipping 48 matching lines @@
   base::StringAppendF(&str,
                       "overscroll_rounding_error_: %s ",
                       overscroll_rounding_error_.ToString().c_str());
   base::StringAppendF(
       &str, "on_new_picture_enable: %d ", on_new_picture_enable_);
   base::StringAppendF(&str, "clear_view: %d ", clear_view_);
   return str;
 }
 
 }  // namespace android_webview