compositor-worker: cc->blink mutation plumbing

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 982 matching lines @@
     const gfx::Vector2dF& inner_delta,
     const gfx::Vector2dF& outer_delta,
     const gfx::Vector2dF& elastic_overscroll_delta,
     float page_scale,
     float top_controls_delta) {
   webwidget_->applyViewportDeltas(inner_delta, outer_delta,
                                   elastic_overscroll_delta, page_scale,
                                   top_controls_delta);
 }
 
+void RenderWidget::ApplyMutations(const cc::LayerTreeMutations& mutations) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
+               "RenderWidget::ApplyMutations");
+  webwidget_->applyCompositorMutations(
+      static_cast<const blink::WebCompositorMutations&>(mutations));

[piman, 2016/01/29 01:50:08]

This bothers me a little, because I have no way of knowing whether the
static_cast is safe (I guess the code that fills
BeginMainFrameAndCommitState::mutations is not in this CL).

Taking a step back, if I understand where this is going, LayerTreeMutations
doesn't really have anything to do with cc - it's just some placeholder type so
that some data can flow backwards (impl->main) through the commit flow, but cc
never cares about the data itself.

In a way, it's the pendant of SwapPromise (just works the other way around). So
maybe we could introduce a BeginMainFramePromise or something like that, with a
virtual DidBeginMainFrame() - or maybe even more simply a BeginMainFrameCallback
that could be stashed on the impl thread, and executed on the main thread? This
would give us back the type safety, because the callback could encode the
concrete type in the curried data (or the concrete implementation of
BeginMainFramePromise would contain the concrete data). It could also be reused
for other purpose (e.g. scroll/viewport deltas, maybe input events, etc.).

WDYT?

+}
+
 void RenderWidget::BeginMainFrame(double frame_time_sec) {
   webwidget_->beginFrame(frame_time_sec);
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
   DCHECK(webwidget_);
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
   DCHECK(!compositor_never_visible_);
 
@@ skipping 1258 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content