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 310 matching lines @@
       is_showing_(!widget_host->is_hidden()),
       content_view_core_(nullptr),
       content_view_core_window_android_(nullptr),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       gesture_provider_(ui::GetGestureProviderConfig(
                             ui::GestureProviderConfigType::CURRENT_PLATFORM),
                         this),
       stylus_text_selector_(this),
-      using_browser_compositor_(CompositorImpl::IsInitialized()),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false),
       weak_ptr_factory_(this) {
   if (CompositorImpl::GetSurfaceManager())
     id_allocator_ = CompositorImpl::CreateSurfaceIdAllocator();
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 }
 
@@ skipping 523 matching lines @@
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const ReadbackRequestCallback& callback,
     const SkColorType preferred_color_type) {
   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurface");
   if (!host_ || host_->is_hidden()) {
     callback.Run(SkBitmap(), READBACK_SURFACE_UNAVAILABLE);
     return;
   }
   base::TimeTicks start_time = base::TimeTicks::Now();
-  if (using_browser_compositor_ && !IsSurfaceAvailableForCopy()) {
+  if (!sync_compositor_ && !IsSurfaceAvailableForCopy()) {

[no sievers, 2015/10/07 18:52:58]

nit: Actually even better would be to remove the sync_compositor_ check here and
add this:

bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
  // We can always produce a frame in that case.
  if (sync_compositor_)
    return true;

[boliu, 2015/10/08 03:14:44]

Done.

     callback.Run(SkBitmap(), READBACK_SURFACE_UNAVAILABLE);
     return;
   }
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   float device_scale_factor = display.device_scale_factor();
   gfx::Size dst_size_in_pixel =
       gfx::ConvertRectToPixel(device_scale_factor, gfx::Rect(dst_size)).size();
   gfx::Rect src_subrect_in_pixel =
       gfx::ConvertRectToPixel(device_scale_factor, src_subrect);
 
-  if (!using_browser_compositor_) {
+  if (sync_compositor_) {
     SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback,
                             preferred_color_type);
     UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
                         base::TimeTicks::Now() - start_time);
     return;
   }
 
   scoped_ptr<cc::CopyOutputRequest> request;
   scoped_refptr<cc::Layer> readback_layer;
   DCHECK(content_view_core_window_android_);
@@ skipping 271 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 12 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
   if (layer_.get())
     layer_->SetContentsOpaque(!enabled);
 }
 
 bool RenderWidgetHostViewAndroid::SupportsAnimation() const {
   // The synchronous (WebView) compositor does not have a proper browser
   // compositor with which to drive animations.
-  return using_browser_compositor_;
+  return !sync_compositor_;
 }
 
 void RenderWidgetHostViewAndroid::SetNeedsAnimate() {
   DCHECK(content_view_core_window_android_);
-  DCHECK(using_browser_compositor_);
+  DCHECK(!sync_compositor_);
   content_view_core_window_android_->SetNeedsAnimate();
 }
 
 void RenderWidgetHostViewAndroid::MoveCaret(const gfx::PointF& position) {
   MoveCaret(gfx::Point(position.x(), position.y()));
 }
 
 void RenderWidgetHostViewAndroid::MoveRangeSelectionExtent(
     const gfx::PointF& extent) {
   DCHECK(content_view_core_);
@@ skipping 17 matching lines @@
   if (event == ui::SELECTION_HANDLES_SHOWN)
     ResetGestureDetection();
   content_view_core_->OnSelectionEvent(
       event, selection_controller_->GetStartPosition(),
       GetSelectionRect(*selection_controller_));
 }
 
 scoped_ptr<ui::TouchHandleDrawable>
 RenderWidgetHostViewAndroid::CreateDrawable() {
   DCHECK(content_view_core_);
-  if (!using_browser_compositor_)
+  if (sync_compositor_)
     return PopupTouchHandleDrawable::Create(content_view_core_);
 
   return scoped_ptr<ui::TouchHandleDrawable>(new CompositedTouchHandleDrawable(
       content_view_core_->GetLayer().get(),
       content_view_core_->GetDpiScale(),
       // Use the activity context (instead of the application context) to ensure
       // proper handle theming.
       content_view_core_->GetContext().obj()));
 }
 
 void RenderWidgetHostViewAndroid::SynchronousCopyContents(
     const gfx::Rect& src_subrect_in_pixel,
     const gfx::Size& dst_size_in_pixel,
     const ReadbackRequestCallback& callback,
     const SkColorType color_type) {
+  DCHECK(sync_compositor_);
   gfx::Size input_size_in_pixel;
   if (src_subrect_in_pixel.IsEmpty())
     input_size_in_pixel = texture_size_in_layer_;
   else
     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) {
-    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 154 matching lines @@
 
   observing_root_window_ = false;
   content_view_core_window_android_->RemoveObserver(this);
 }
 
 void RenderWidgetHostViewAndroid::SendBeginFrame(base::TimeTicks frame_time,
                                                  base::TimeDelta vsync_period) {
   TRACE_EVENT1("cc", "RenderWidgetHostViewAndroid::SendBeginFrame",
                "frame_time_us", frame_time.ToInternalValue());
 
-  if (using_browser_compositor_) {
+  if (!sync_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));
-    }
+    // 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 111 matching lines @@
 }
 
 uint32_t RenderWidgetHostViewAndroid::GetSurfaceIdNamespace() {
   if (id_allocator_)
     return id_allocator_->id_namespace();
   return 0;
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
+  // Android webview does not currently support switching ContentViewCoreImpl.
+  DCHECK_IMPLIES(sync_compositor_,
+                 !content_view_core || !content_view_core_);

[no sievers, 2015/10/07 18:52:58]

So this is what I think we support here:

- setting CVC to NULL when WebContents gets destroyed
- setting CVC to NULL when Java CVC gets destroyed (because CVC is not
functional then)
- reset to null from destructor
- calling this from RWHVA constructor i.e. init with CVC/WebContents
- the renderer crashed and we create a new RWHV for an existing CVC/WebContents.
I'm *guessing* that RWHVA might then get created without a CVC and we later call
SetCVC() from ContentViewCoreImpl::RenderViewHostChanged().

So the check could actually go a bit further and also rule out this:
RWHVA::SetCVC(cvc1);
RWHVA::SetCVC(null);
RWHVA::SetCVC(cvc2);

[boliu, 2015/10/08 03:14:44]

That case sounds the same as normally creating CVC/WebContents, ie constructor
has the CVC pointer?

Other case where CVC can be set after construction include pop up windows (at
least in webview)
Err, how do you do that inside SetCVC itself? Want me to add a bool that's like
"had_cvc_before_"?

[no sievers, 2015/10/08 22:39:29]

Maybe splitting up this function into AttachToContentViewCore(CVC*) and
DetachFromContentViewCore() would also make it a bit clearer what's going on
here. But would still need some bool was_attached_ that can never be reset.

Maybe something for a separate patch. Although... you do care about this, right?
Because if it happened you'd end up with an existing SyncCompositor that points
to the wrong (and possibly deleted) SyncCompositorClient.

(There are also most likely corner case bugs in this anyways since calling
WCV->SetContentViewCore()from CVC is dynamic wrt what RWHV it ends up forwarding
this to.)

[boliu, 2015/10/09 02:22:16]

Yes. But that never happens (yet) in webview, since it would have completely
broken rendering, with or without this patch.

   RemoveLayers();
   StopObservingRootWindow();
 
   bool resize = false;
   if (content_view_core != content_view_core_) {
     overscroll_controller_.reset();
     selection_controller_.reset();
     ReleaseLocksOnSurface();
     resize = true;
   }
 
   content_view_core_ = content_view_core;
   content_view_core_window_android_ =
       content_view_core_ ? content_view_core_->GetWindowAndroid() : nullptr;
   DCHECK_EQ(!!content_view_core_, !!content_view_core_window_android_);
 
   BrowserAccessibilityManager* manager = NULL;
   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();

[no sievers, 2015/10/07 18:52:57]

Actually I missed that if you do this, then some of the check for
sync_compositor_ in here might be dangerous and lead you to take the browser
compositor path when the WebContents went away or so.

[boliu, 2015/10/08 03:14:44]

Hmm, you are right. CVC can be set much later after RWHVA is created, so even
checking if there is a sync client set is not good enough in general. Reverted
back to using_browser_compositor_ logic I guess

[no sievers, 2015/10/08 22:39:29]

Ok. Maybe we can revisit later. For example, maybe it's nicer to always have a
fixed interface here that always exist (but will then internally get detached
from the SyncCompositor or maybe just the SyncCompositor getting detached from
its client). It's a bit related to my other comment about WebContents and
views/windows.

[boliu, 2015/10/09 02:22:16]

Maybe don't need that. I think most RVHWA is created with a CVC, so has the
SyncCompositorClient set already. For the edge case RVHWA created for pop up,
could just inherit the value from the source RVHWA where the pop up is created
from.

But yeah, separate patch maybe.

     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 (!sync_compositor_) {
+    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 28 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::OnAttachCompositor() {
   DCHECK(content_view_core_);
   if (!overscroll_controller_)
     overscroll_controller_ = CreateOverscrollController(content_view_core_);
 }
 
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   DCHECK(content_view_core_);
-  DCHECK(using_browser_compositor_);
+  DCHECK(!sync_compositor_);
   RunAckCallbacks(cc::SurfaceDrawStatus::DRAW_SKIPPED);
   overscroll_controller_.reset();
 }
 
 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
                                           base::TimeDelta vsync_period) {
   TRACE_EVENT0("cc,benchmark", "RenderWidgetHostViewAndroid::OnVSync");
   if (!host_ || host_->is_hidden())
     return;
 
@@ skipping 161 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