Implement webview.captureVisibleRegion()

content/browser/frame_host/render_widget_host_view_child_frame.h

 // 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.
 
 #ifndef CONTENT_BROWSER_FRAME_HOST_RENDER_WIDGET_HOST_VIEW_CHILD_FRAME_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_WIDGET_HOST_VIEW_CHILD_FRAME_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <deque>
 #include <vector>
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/readback_types.h"
@@ skipping 28 matching lines @@
       public cc::SurfaceFactoryClient {
  public:
   explicit RenderWidgetHostViewChildFrame(RenderWidgetHost* widget);
   ~RenderWidgetHostViewChildFrame() override;
 
   void set_cross_process_frame_connector(
       CrossProcessFrameConnector* frame_connector) {
     frame_connector_ = frame_connector;
   }
 
+  // This functions registers single-use callbacks that want to be notified when
+  // the next frame is drawn. Once called, the callback pointer is released.
+  // TODO(wjmaclean): We should consider making this available in other view
+  // types, such as RenderWidgetHostViewAura.

[ncarter (slow), 2016/01/27 21:08:25]

This seems fairly similar in purpose to RenderWidgetHostViewFrameSubscriber,
though the abilities of that interface is currently narrowly scoped to what
WebContentsVideoCaptureDevice needs (only one subscriber is supported, it
assumes a stream of frames, and it assumes you want things like YV12 that are
appropriate for dumping into a video encode).

[wjmaclean, 2016/01/27 21:28:01]

Are you suggesting we re-write RenderWidgetHostViewFrameSubscriber then to be
more general?

[ncarter (slow), 2016/01/28 20:49:58]

My main intent was to call attention to the RenderWidgetHostViewFrameSubscriber
methods in RWHVBase, which seems like it has some level of functional overlap
with this -- which I thought was potentially worth mentioning in the TODO.

Having done a little more thinking, I am now wondering whether an even better
long-term approach might be for RenderWidgetHostViewFrameSubscriber to be
eliminated, and have WebContentsVideoCaptureDevice's FrameSubscriber be
implemented in terms of something simpler like RegisterFrameDrawnCallback.
RenderWidgetHostViewFrameSubscriber originally had some really gnarly threading
behaviors, and had to be driven substantially differently between platforms. I
don't think any of these are concerns anymore: DelegatedFrameHost drives the
FrameSubscriber on all platforms, and WCVCD's FrameSubscriber is in content (and
thus can do content-impl things), so if we provided some kind of hook at
compositor-swap time (i.e. RegisterFrameDrawnCallback), maybe the rest of the
FrameSubscriber-specific behavior could be moved out of DelegatedFrameHost.

Anyhow: the upshot of this is that I'm on board with RWHVBase having a
RegisterFrameDrawnCallback.

[miu, 2016/02/04 20:19:11]

Agreed.  I have it on my roadmap this year to do some significant refactoring in
this area.  In particular, FrameSubscriber was solving problems in the
"pre-Uber-Compositor world" and has suffered some rather weird code factoring
issues over the past 2+ years.  In one case (that I was not aware of at the
time), someone threw up their arms and just copy-and-pasted a bunch of code from
DelegatedFrameHost in order to implement screen capture on CrOS.  That's not
good.

So, for the future, I think it makes sense for the Compositor to provide some
kind of "frame observer" interface instead of the RenderWidgetHostView*
providing a "frame subscriber" interface.  I have a number of ideas that I plan
to prototype-out before proposing a new design.
I'm not sure it will stay that way for long, but I don't see this as a bad idea
now, nor would it seem to make my future refactoring efforts any more difficult.

+  void RegisterFrameDrawnCallback(scoped_ptr<base::Closure> callback);

[ncarter (slow), 2016/01/27 21:08:25]

In the webview case, is there really necessarily a "frame drawn" event in the
RWHVChildFrame for every visible change to the pixel content (I'm thinking about
when there are oopifs or, I dunno, flash or something, that could cause an
additional delegated layer under the current one)?

If these were OOPIFs, then in the A(B(C)) case, if we're capturing B, will
reading from B's RWHVChildFrame actually include the pixel content from C?

[wjmaclean, 2016/01/27 21:28:01]

I'm not entirely sure, though I suspect the surface for B would include it. It's
easy enough to test.

[ncarter (slow), 2016/01/28 20:49:58]

OK.

[miu, 2016/02/04 20:19:10]

My understanding here is that the Compositor will execute a "copy request on
layer B" on the result from drawing "B(C)".  In other words, I'd expect to see
the pixels for B and C.

+
   // RenderWidgetHostView implementation.
   void InitAsChild(gfx::NativeView parent_view) override;
   RenderWidgetHost* GetRenderWidgetHost() const override;
   void SetSize(const gfx::Size& size) override;
   void SetBounds(const gfx::Rect& rect) override;
   void Focus() override;
   bool HasFocus() const override;
   bool IsSurfaceAvailableForCopy() const override;
   void Show() override;
   void Hide() override;
@@ skipping 128 matching lines @@
 
   // frame_connector_ provides a platform abstraction. Messages
   // sent through it are routed to the embedding renderer process.
   CrossProcessFrameConnector* frame_connector_;
 
   base::WeakPtr<RenderWidgetHostViewChildFrame> AsWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
  private:
+  void SubmitSurfaceCopyRequest(const gfx::Rect& src_subrect,
+                                const gfx::Size& dst_size,
+                                const ReadbackRequestCallback& callback,
+                                const SkColorType preferred_color_type);
+
+  using FrameDrawnCallbackList = std::deque<scoped_ptr<base::Closure>>;
+  // Since frame-drawn callbacks are "fire once", we use std::deque to make
+  // it convenient to swap() when processing the list.
+  FrameDrawnCallbackList frame_drawn_callbacks_;
   base::WeakPtrFactory<RenderWidgetHostViewChildFrame> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewChildFrame);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_WIDGET_HOST_VIEW_CHILD_FRAME_H_