Have RenderWidgetHostViewAndroid own sync compositor

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 2012 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/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 1158 matching lines @@
         base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
                    weak_ptr_factory_.GetWeakPtr(),
                    last_frame_info_->output_surface_id);
 
     ack_callbacks_.push(ack_callback);
   }
 
   last_frame_info_.reset(new LastFrameInfo(output_surface_id, frame.Pass()));
 }
 
+SynchronousCompositorImpl*
+RenderWidgetHostViewAndroid::GetSynchronousCompositorImpl() {
+  return sync_compositor_.get();
+}
+
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
     const cc::CompositorFrameMetadata& frame_metadata) {
   if (!content_view_core_)
     return;
 
   // This is a subset of OnSwapCompositorFrame() used in the synchronous
   // compositor flow.
   OnFrameMetadataUpdated(frame_metadata);
 
   // DevTools ScreenCast support for Android WebView.
@@ skipping 85 matching lines @@
     input_size_in_pixel = src_subrect_in_pixel.size();
 
   gfx::Size output_size_in_pixel;
   if (dst_size_in_pixel.IsEmpty())
     output_size_in_pixel = input_size_in_pixel;
   else
     output_size_in_pixel = dst_size_in_pixel;
   int output_width = output_size_in_pixel.width();
   int output_height = output_size_in_pixel.height();
 
-  SynchronousCompositor* compositor =
-      SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
-                                        host_->GetRoutingID());
-  if (!compositor) {
+  if (!sync_compositor_) {
     callback.Run(SkBitmap(), READBACK_FAILED);
     return;
   }
 
   SkBitmap bitmap;
   bitmap.allocPixels(SkImageInfo::Make(output_width,
                                        output_height,
                                        color_type,
                                        kPremul_SkAlphaType));
   SkCanvas canvas(bitmap);
   canvas.scale(
       (float)output_width / (float)input_size_in_pixel.width(),
       (float)output_height / (float)input_size_in_pixel.height());
-  compositor->DemandDrawSw(&canvas);
+  sync_compositor_->DemandDrawSw(&canvas);
   callback.Run(bitmap, READBACK_SUCCESS);
 }
 
 void RenderWidgetHostViewAndroid::OnFrameMetadataUpdated(
     const cc::CompositorFrameMetadata& frame_metadata) {
   bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
   gesture_provider_.SetDoubleTapSupportForPageEnabled(!is_mobile_optimized);
 
   if (!content_view_core_)
     return;
@@ skipping 163 matching lines @@
 
   if (using_browser_compositor_) {
     // TODO(brianderson): Replace this hardcoded deadline after Android
     // switches to Surfaces and the Browser's commit isn't in the critcal path.
     base::TimeTicks deadline = frame_time + (vsync_period * 0.6);
 
     host_->Send(new ViewMsg_BeginFrame(
         host_->GetRoutingID(),
         cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
                                    vsync_period, cc::BeginFrameArgs::NORMAL)));
-  } else {
-    SynchronousCompositorImpl* compositor = SynchronousCompositorImpl::FromID(
-        host_->GetProcess()->GetID(), host_->GetRoutingID());
-    if (compositor) {
-      // The synchronous compositor synchronously does it's work in this call.
-      // It does not use a deadline.
-      compositor->BeginFrame(cc::BeginFrameArgs::Create(
-          BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks(), vsync_period,
-          cc::BeginFrameArgs::NORMAL));
-    }
+  } else if (sync_compositor_.get()) {
+    // The synchronous compositor synchronously does it's work in this call.
+    // It does not use a deadline.
+    sync_compositor_->BeginFrame(cc::BeginFrameArgs::Create(
+        BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks(), vsync_period,
+        cc::BeginFrameArgs::NORMAL));
   }
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
   bool needs_animate = false;
   if (overscroll_controller_) {
     needs_animate |= overscroll_controller_->Animate(
         frame_time, content_view_core_->GetLayer().get());
   }
   if (selection_controller_)
@@ skipping 97 matching lines @@
 
   if (input_event.type == blink::WebInputEvent::GestureTapDown ||
       input_event.type == blink::WebInputEvent::TouchStart) {
     GpuDataManagerImpl* gpu_data = GpuDataManagerImpl::GetInstance();
     GpuProcessHostUIShim* shim = GpuProcessHostUIShim::GetOneInstance();
     if (shim && gpu_data &&
         gpu_data->IsDriverBugWorkaroundActive(gpu::WAKE_UP_GPU_BEFORE_DRAWING))
       shim->Send(new GpuMsg_WakeUpGpu);
   }
 
-  SynchronousCompositorImpl* compositor =
-      SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
-                                          host_->GetRoutingID());
-  if (compositor)
-    return compositor->HandleInputEvent(input_event);
+  if (sync_compositor_.get())
+    return sync_compositor_->HandleInputEvent(input_event);
   return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 }
 
 void RenderWidgetHostViewAndroid::OnSetNeedsFlushInput() {
   TRACE_EVENT0("input", "RenderWidgetHostViewAndroid::OnSetNeedsFlushInput");
   RequestVSyncUpdate(FLUSH_INPUT);
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostViewAndroid::CreateBrowserAccessibilityManager(
@@ skipping 138 matching lines @@
   if (host_)
     manager = host_->GetRootBrowserAccessibilityManager();
   if (manager) {
     base::android::ScopedJavaLocalRef<jobject> obj;
     if (content_view_core_)
       obj = content_view_core_->GetJavaObject();
     manager->ToBrowserAccessibilityManagerAndroid()->SetContentViewCore(obj);
   }
 
   AttachLayers();
-
-  if (!content_view_core_)
+  if (!content_view_core_) {
+    sync_compositor_.reset();

[jdduke (slow), 2015/10/05 19:56:03]

What about the case where we transition from one valid CVC to another valid CVC?
Should this reset go aove in the |content_view_core != content_view_core_|
check?

[boliu, 2015/10/06 00:05:30]

Assume for now there will be only one RenderView per WebContents in webview.

Given that... Why does CVC change here? I mean what is it for?

[boliu, 2015/10/06 01:28:04]

Let me re-phrase that a bit better, now that I'm not on a phone anymore.

In what siuation does clank need to switch the CVC instance of RWHVA? I thought
the relationship is one to many, but the many is RVHWVA, not CVC?

     return;
+  }
 
   if (is_showing_)
     StartObservingRootWindow();
 
   if (resize)
     WasResized();
 
   if (!selection_controller_)
     selection_controller_ = CreateSelectionController(this, content_view_core_);
 
   if (!overscroll_controller_ &&
       content_view_core_window_android_->GetCompositor()) {
     overscroll_controller_ = CreateOverscrollController(content_view_core_);
   }
+
+  if (!using_browser_compositor_ && !sync_compositor_.get()) {
+    sync_compositor_ = SynchronousCompositorImpl::Create(
+        this, content_view_core_->GetWebContents());
+  }
 }
 
 void RenderWidgetHostViewAndroid::RunAckCallbacks(
     cc::SurfaceDrawStatus status) {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
     ack_callbacks_.pop();
   }
 }
 
@@ skipping 210 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 }  // namespace content