Migrate Telemetry from beginWindowSnapshotPNG to Page.captureScreenshot

content/browser/renderer_host/render_widget_host_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 159 matching lines @@
   virtual void WasResized() OVERRIDE;
   virtual void AddKeyPressEventCallback(
       const KeyPressEventCallback& callback) OVERRIDE;
   virtual void RemoveKeyPressEventCallback(
       const KeyPressEventCallback& callback) OVERRIDE;
   virtual void AddMouseEventCallback(
       const MouseEventCallback& callback) OVERRIDE;
   virtual void RemoveMouseEventCallback(
       const MouseEventCallback& callback) OVERRIDE;
   virtual void GetWebScreenInfo(blink::WebScreenInfo* result) OVERRIDE;
   virtual void GetSnapshotFromRenderer(

[pfeldman, 2014/03/07 12:21:22]

It looks like this method is the wrong way of doing what you are trying to do
the right way. Why not to fix it instead? And reuse exising IPC message
ViewMsg_Snapshot that is supposed to do the same thing as ForcePaint that you
introduce.

[Vladislav Kaznacheev, 2014/03/11 13:08:56]

This method is used when the compositor is not available, so it cannot be
replaced with what I am adding.

On 2014/03/07 12:21:22, pfeldman wrote:

       const gfx::Rect& src_subrect,
       const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE;
 
   const NativeWebKeyboardEvent* GetLastKeyboardEvent() const;
 
   // Notification that the screen info has changed.
   void NotifyScreenInfoChanged();
 
   // Invalidates the cached screen info so that next resize request
   // will carry the up to date screen info. Unlike
@@ skipping 354 matching lines @@
   // Returns the ID that uniquely describes this component to the latency
   // subsystem.
   int64 GetLatencyComponentId();
 
   static void CompositorFrameDrawn(
       const std::vector<ui::LatencyInfo>& latency_info);
 
   // Don't check whether we expected a resize ack during layout tests.
   static void DisableResizeAckCheckForTesting();
 
+  typedef base::Callback<void(const unsigned char*, size_t)>
+      WindowSnapshotCallback;
+  void RequestWindowSnapshot(const WindowSnapshotCallback&);
+
   void WindowSnapshotAsyncCallback(

[pfeldman, 2014/03/07 12:21:22]

TODO(kaznacheev): retire.

[Vladislav Kaznacheev, 2014/03/11 13:08:56]

Done.

       int routing_id,
       int snapshot_id,
       gfx::Size snapshot_size,
       scoped_refptr<base::RefCountedBytes> png_data);
 
   // LatencyComponents generated in the renderer must have component IDs
   // provided to them by the browser process. This function adds the correct
   // component ID where necessary.
   void AddLatencyInfoComponentIds(ui::LatencyInfo* latency_info);
 
@@ skipping 190 matching lines @@
   virtual void OnGestureEventAck(const GestureEventWithLatencyInfo& event,
                                  InputEventAckState ack_result) OVERRIDE;
   virtual void OnUnexpectedEventAck(UnexpectedEventAckType type) OVERRIDE;
 
   void OnSyntheticGestureCompleted(SyntheticGesture::Result result);
 
   // Called when there is a new auto resize (using a post to avoid a stack
   // which may get in recursive loops).
   void DelayedAutoResized();
 
+  // TODO(kaznacheev): Remove this method when GpuBenchmarking V8 extension is
+  // retired.
+  void WindowSnapshotReachedScreenUnsafe(int snapshot_id);
+
   void WindowSnapshotReachedScreen(int snapshot_id);
 
+  void OnSnapshotDataReceived(int snapshot_id,
+                              const unsigned char* png,
+                              size_t size);
+
+  void OnSnapshotDataReceivedAsync(
+      int snapshot_id,
+      scoped_refptr<base::RefCountedBytes> png_data);
+
   // Send a message to the renderer process to change the accessibility mode.
   void SetAccessibilityMode(AccessibilityMode AccessibilityMode);
 
   // Our delegate, which wants to know mainly about keyboard events.
   // It will remain non-NULL until DetachDelegate() is called.
   RenderWidgetHostDelegate* delegate_;
 
   // Created during construction but initialized during Init*(). Therefore, it
   // is guaranteed never to be NULL, but its channel may be NULL if the
   // renderer crashed, so you must always check that.
@@ skipping 157 matching lines @@
 
 #if defined(OS_WIN)
   std::list<HWND> dummy_windows_for_activation_;
 #endif
 
   // List of callbacks for pending snapshot requests to the renderer.
   std::queue<base::Callback<void(bool, const SkBitmap&)> > pending_snapshots_;
 
   int64 last_input_number_;
 
+  int next_window_snapshot_id_;
+  typedef std::map<int, WindowSnapshotCallback> PendingSnapshotMap;
+  PendingSnapshotMap pending_window_snapshots_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_