Move fallback tick handling to compositor thread

content/renderer/android/synchronous_compositor_output_surface.cc

 // Copyright 2013 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 "content/renderer/android/synchronous_compositor_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "content/renderer/android/synchronous_compositor_external_begin_frame_source.h"
 #include "content/renderer/android/synchronous_compositor_registry.h"
 #include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace content {
 
 namespace {
 
+const int64_t kFallbackTickTimeoutInMilliseconds = 100;
+
 // Do not limit number of resources, so use an unrealistically high value.
 const size_t kNumResourcesLimit = 10 * 1000 * 1000;
 
 }  // namespace
 
 class SynchronousCompositorOutputSurface::SoftwareDevice
   : public cc::SoftwareOutputDevice {
  public:
   SoftwareDevice(SynchronousCompositorOutputSurface* surface)
     : surface_(surface) {
@@ skipping 86 matching lines @@
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
   sync_client_->SwapBuffers(frame);
   client_->DidSwapBuffers();
   did_swap_ = true;
 }
 
+void SynchronousCompositorOutputSurface::FallbackTickFired() {

[boliu, 2016/03/11 17:43:09]

DCHECK(CalledOnValidThread());

[Tobias Sargeant, 2016/03/14 13:11:03]

Done.

+  TRACE_EVENT0("android_webview",

[boliu, 2016/03/11 17:43:09]

change category to "renderer"

[Tobias Sargeant, 2016/03/14 13:11:03]

Done.

+               "SynchronousCompositorOutputSurface::FallbackTickFired");
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(1, 1);
+  bitmap.eraseColor(0);
+  SkCanvas canvas(bitmap);
+  DemandDrawSw(&canvas);
+}
+
 void SynchronousCompositorOutputSurface::Invalidate() {
   DCHECK(CalledOnValidThread());
   if (sync_client_)
     sync_client_->Invalidate();
+
+  fallback_tick_.Reset(

[boliu, 2016/03/11 17:43:09]

Need to check if fallback tick is already pending, so this doesn't end up in a
live lock where compositor calls invalidate more frequently than ticks, so it
gets pushed back indefinitely.

[Tobias Sargeant, 2016/03/14 13:11:03]

Done.

+      base::Bind(&SynchronousCompositorOutputSurface::FallbackTickFired,
+                 base::Unretained(this)));
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, fallback_tick_.callback(),
+      base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
 }
 
 void SynchronousCompositorOutputSurface::DemandDrawHw(
     const gfx::Size& surface_size,
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
     const gfx::Rect& clip,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
   DCHECK(context_provider_.get());
+  fallback_tick_.Cancel();
 
   surface_size_ = surface_size;
   client_->SetExternalTilePriorityConstraints(viewport_rect_for_tile_priority,
                                               transform_for_tile_priority);
   const bool software_draw = false;
   InvokeComposite(transform, viewport, clip, software_draw);
 }
 
 void SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   DCHECK(canvas);
   DCHECK(!current_sw_canvas_);
+  fallback_tick_.Cancel();
 
   base::AutoReset<SkCanvas*> canvas_resetter(&current_sw_canvas_, canvas);
 
   SkIRect canvas_clip;
   canvas->getClipDeviceBounds(&canvas_clip);
   gfx::Rect clip = gfx::SkIRectToRect(canvas_clip);
 
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix() = canvas->getTotalMatrix();  // Converts 3x3 matrix to 4x4.
 
@@ skipping 56 matching lines @@
   scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
   frame_swap_message_queue_->DrainMessages(messages);
 }
 
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace content