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 13 matching lines @@
 const size_t kBytesPerPixel = 4;
 const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
 
 // Used to calculate tile allocation. Determined experimentally.
 const size_t kTileMultiplier = 12;
 const size_t kTileAllocationStep = 20;
 // This will be set by static function CalculateTileMemoryPolicy() during init.
 // See AwMainDelegate::BasicStartupComplete.
 size_t g_tile_area;
 
-class AutoResetWithLock {
- public:
-  AutoResetWithLock(gfx::Vector2dF* scoped_variable,
-                    gfx::Vector2dF new_value,
-                    base::Lock& lock)
-      : scoped_variable_(scoped_variable),
-        original_value_(*scoped_variable),
-        lock_(lock) {
-    base::AutoLock auto_lock(lock_);
-    *scoped_variable_ = new_value;
-  }
-
-  ~AutoResetWithLock() {
-    base::AutoLock auto_lock(lock_);
-    *scoped_variable_ = original_value_;
-  }
-
- private:
-  gfx::Vector2dF* scoped_variable_;
-  gfx::Vector2dF original_value_;
-  base::Lock& lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(AutoResetWithLock);
-};
-
 class TracedValue : public base::debug::ConvertableToTraceFormat {
  public:
   explicit TracedValue(base::Value* value) : value_(value) {}
   static scoped_refptr<base::debug::ConvertableToTraceFormat> FromValue(
       base::Value* value) {
     return scoped_refptr<base::debug::ConvertableToTraceFormat>(
         new TracedValue(value));
   }
   virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
     std::string tmp;
@@ skipping 30 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);
-}
-
 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();
     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);
   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);
+  DidComposite();
   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.
+    // TODO(boliu): Do this PostTask in AwContents instead so every method in
+    // this class is called by UI thread.
     ui_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&BrowserViewRenderer::DidDrawDelegated,

[hush (inactive), 2014/06/17 17:45:54]

i see the only place where DidDrawDelegated is called is in aw_contents DrawGL
function, which is run on the render thread. So do you even need the if
statement?

[boliu, 2014/06/17 17:47:23]

Yes because it then calls *itself* on UI thread...I know this needs to
restructured, but I want to keep this change mostly removing code.

-                                         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,
             base::Bind(&BrowserViewRenderer::CompositeSW,
                        base::Unretained(this)));
 }
 
 skia::RefPtr<SkPicture> BrowserViewRenderer::CapturePicture(int width,
                                                             int height) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::CapturePicture");
 
   // Return empty Picture objects for empty SkPictures.
   if (width <= 0 || height <= 0) {
     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_);
+  base::AutoReset<gfx::Vector2dF> scroll_reset(&scroll_offset_dip_,
+                                               gfx::Vector2dF());
 
   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(ui_task_runner_->BelongsToCurrentThread());
-  has_compositor_ = true;
-  shared_renderer_state_->SetCompositorOnUiThread(compositor);
+  DCHECK(!compositor_);
+  compositor_ = compositor;
 }
 
 void BrowserViewRenderer::DidDestroyCompositor(
     content::SynchronousCompositor* compositor) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::DidDestroyCompositor");
-  DCHECK(has_compositor_);
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  has_compositor_ = false;
-  shared_renderer_state_->SetCompositorOnUiThread(NULL);
+  DCHECK(compositor_);
+  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;
+  if (compositor_needs_continuous_invalidate_ == invalidate)
+    return;
 
-    TRACE_EVENT_INSTANT1("android_webview",
-                         "BrowserViewRenderer::SetContinuousInvalidate",
-                         TRACE_EVENT_SCOPE_THREAD,
-                         "invalidate",
-                         invalidate);
-    compositor_needs_continuous_invalidate_ = invalidate;
-  }
+  TRACE_EVENT_INSTANT1("android_webview",
+                       "BrowserViewRenderer::SetContinuousInvalidate",
+                       TRACE_EVENT_SCOPE_THREAD,
+                       "invalidate",
+                       invalidate);
+  compositor_needs_continuous_invalidate_ = invalidate;
 
-  if (ui_task_runner_->BelongsToCurrentThread()) {
-    EnsureContinuousInvalidation(false);
-    return;
-  }
-  ui_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&BrowserViewRenderer::EnsureContinuousInvalidation,
-                 ui_thread_weak_ptr_,
-                 false));
+  EnsureContinuousInvalidation(false);
 }
 
 void BrowserViewRenderer::SetDipScale(float dip_scale) {
   dip_scale_ = dip_scale;
   CHECK(dip_scale_ > 0);
 }
 
 gfx::Vector2d BrowserViewRenderer::max_scroll_offset() const {
   DCHECK_GT(dip_scale_, 0);
   return gfx::ToCeiledVector2d(gfx::ScaleVector2d(
@@ skipping 14 matching lines @@
   if (max_offset.y()) {
     scroll_offset_dip.set_y((scroll_offset.y() * max_scroll_offset_dip_.y()) /
                             max_offset.y());
   }
 
   DCHECK_LE(0, scroll_offset_dip.x());
   DCHECK_LE(0, scroll_offset_dip.y());
   DCHECK_LE(scroll_offset_dip.x(), max_scroll_offset_dip_.x());
   DCHECK_LE(scroll_offset_dip.y(), max_scroll_offset_dip_.y());
 
-  {
-    base::AutoLock lock(render_thread_lock_);
-    if (scroll_offset_dip_ == scroll_offset_dip)
-      return;
+  if (scroll_offset_dip_ == scroll_offset_dip)
+    return;
 
-    scroll_offset_dip_ = scroll_offset_dip;
-  }
+  scroll_offset_dip_ = scroll_offset_dip;
 
   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",
                        "BrowserViewRenderer::DidUpdateContent",
                        TRACE_EVENT_SCOPE_THREAD);
   clear_view_ = false;
   if (on_new_picture_enable_)
     client_->OnNewPicture();
 }
 
 void BrowserViewRenderer::SetTotalRootLayerScrollOffset(
     gfx::Vector2dF scroll_offset_dip) {
+  // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during
+  // DrawGl when http://crbug.com/249972 is fixed.
+  if (scroll_offset_dip_ == scroll_offset_dip)
+    return;
 
-  {
-    base::AutoLock lock(render_thread_lock_);
-    // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during
-    // DrawGl when http://crbug.com/249972 is fixed.
-    if (scroll_offset_dip_ == scroll_offset_dip)
-      return;
-
-    scroll_offset_dip_ = scroll_offset_dip;
-  }
+  scroll_offset_dip_ = scroll_offset_dip;
 
   gfx::Vector2d max_offset = max_scroll_offset();
   gfx::Vector2d scroll_offset;
   // For an explanation as to why this is done this way see the comment in
   // BrowserViewRenderer::ScrollTo.
   if (max_scroll_offset_dip_.x()) {
     scroll_offset.set_x((scroll_offset_dip.x() * max_offset.x()) /
                         max_scroll_offset_dip_.x());
   }
 
   if (max_scroll_offset_dip_.y()) {
     scroll_offset.set_y((scroll_offset_dip.y() * max_offset.y()) /
                         max_scroll_offset_dip_.y());
   }
 
   DCHECK(0 <= scroll_offset.x());
   DCHECK(0 <= scroll_offset.y());
   DCHECK(scroll_offset.x() <= max_offset.x());
   DCHECK(scroll_offset.y() <= max_offset.y());
 
   client_->ScrollContainerViewTo(scroll_offset);
 }
 
 gfx::Vector2dF BrowserViewRenderer::GetTotalRootLayerScrollOffset() {
-  base::AutoLock lock(render_thread_lock_);
   return scroll_offset_dip_;
 }
 
 bool BrowserViewRenderer::IsExternalFlingActive() const {
-  if (!ui_task_runner_->BelongsToCurrentThread()) {
-    // TODO(boliu): This is short term hack since we cannot call into
-    // view system on non-UI thread.
-    return false;
-  }
   return client_->IsFlingActive();
 }
 
 void BrowserViewRenderer::UpdateRootLayerState(
     const gfx::Vector2dF& total_scroll_offset_dip,
     const gfx::Vector2dF& max_scroll_offset_dip,
     const gfx::SizeF& scrollable_size_dip,
     float page_scale_factor,
     float min_page_scale_factor,
     float max_page_scale_factor) {
-  if (!ui_task_runner_->BelongsToCurrentThread()) {
-    ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&BrowserViewRenderer::UpdateRootLayerState,
-                   ui_thread_weak_ptr_,
-                   total_scroll_offset_dip,
-                   max_scroll_offset_dip,
-                   scrollable_size_dip,
-                   page_scale_factor,
-                   min_page_scale_factor,
-                   max_page_scale_factor));
-    return;
-  }
   TRACE_EVENT_INSTANT1(
       "android_webview",
       "BrowserViewRenderer::UpdateRootLayerState",
       TRACE_EVENT_SCOPE_THREAD,
       "state",
       TracedValue::FromValue(
           RootLayerStateAsValue(total_scroll_offset_dip, scrollable_size_dip)
               .release()));
 
   DCHECK_GT(dip_scale_, 0);
@@ skipping 27 matching lines @@
   state->SetDouble("scrollable_size_dip.width", scrollable_size_dip.width());
   state->SetDouble("scrollable_size_dip.height", scrollable_size_dip.height());
 
   state->SetDouble("page_scale_factor", page_scale_factor_);
   return state.PassAs<base::Value>();
 }
 
 void BrowserViewRenderer::DidOverscroll(gfx::Vector2dF accumulated_overscroll,
                                         gfx::Vector2dF latest_overscroll_delta,
                                         gfx::Vector2dF current_fling_velocity) {
-  if (!ui_task_runner_->BelongsToCurrentThread()) {
-    ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&BrowserViewRenderer::DidOverscroll,
-                   ui_thread_weak_ptr_,
-                   accumulated_overscroll,
-                   latest_overscroll_delta,
-                   current_fling_velocity));
-    return;
-  }
   const float physical_pixel_scale = dip_scale_ * page_scale_factor_;
   if (accumulated_overscroll == latest_overscroll_delta)
     overscroll_rounding_error_ = gfx::Vector2dF();
   gfx::Vector2dF scaled_overscroll_delta =
       gfx::ScaleVector2d(latest_overscroll_delta, physical_pixel_scale);
   gfx::Vector2d rounded_overscroll_delta = gfx::ToRoundedVector2d(
       scaled_overscroll_delta + overscroll_rounding_error_);
   overscroll_rounding_error_ =
       scaled_overscroll_delta - rounded_overscroll_delta;
   client_->DidOverscroll(rounded_overscroll_delta);
@@ skipping 14 matching lines @@
   // 1) Webview is paused. Also need to check we are not in clear view since
   // paused, offscreen still expect clear view to recover.
   // 2) If we are attached to window and the window is not visible (eg when
   // app is in the background). We are sure in this case the webview is used
   // "on-screen" but that updates are not needed when in the background.
   bool throttle_fallback_tick =
       (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_);
   if (throttle_fallback_tick)
     return;
 
-  {
-    base::AutoLock lock(render_thread_lock_);
-    block_invalidates_ = compositor_needs_continuous_invalidate_;
-  }
+  block_invalidates_ = compositor_needs_continuous_invalidate_;
 
   // Unretained here is safe because the callback is cancelled when
   // |fallback_tick_| is destroyed.
   fallback_tick_.Reset(base::Bind(&BrowserViewRenderer::FallbackTickFired,
                                   base::Unretained(this)));
 
   // No need to reschedule fallback tick if compositor does not need to be
   // ticked. This can happen if this is reached because force_invalidate is
   // true.
   if (compositor_needs_continuous_invalidate_) {
     ui_task_runner_->PostDelayedTask(
         FROM_HERE,
         fallback_tick_.callback(),
         base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
   }
 }
 
 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);
-  DidComposite(false);
+  DCHECK(compositor_);
+  bool result = compositor_->DemandDrawSw(canvas);
+  DidComposite();
   return result;
 }
 
-void BrowserViewRenderer::DidComposite(bool force_invalidate) {
-  {
-    base::AutoLock lock(render_thread_lock_);
-    block_invalidates_ = false;
-  }
-
-  if (!ui_task_runner_->BelongsToCurrentThread()) {
-    ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&BrowserViewRenderer::EnsureContinuousInvalidation,
-                   ui_thread_weak_ptr_,
-                   force_invalidate));
-    return;
-  }
-
+void BrowserViewRenderer::DidComposite() {
+  block_invalidates_ = false;
   fallback_tick_.Cancel();
-  EnsureContinuousInvalidation(force_invalidate);
+  EnsureContinuousInvalidation(false);
 }
 
 std::string BrowserViewRenderer::ToString(AwDrawGLInfo* draw_info) const {
   std::string str;
   base::StringAppendF(&str, "is_paused: %d ", is_paused_);
   base::StringAppendF(&str, "view_visible: %d ", view_visible_);
   base::StringAppendF(&str, "window_visible: %d ", window_visible_);
   base::StringAppendF(&str, "dip_scale: %f ", dip_scale_);
   base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_);
   base::StringAppendF(&str,
@@ skipping 23 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