Replace source pointer in cc::CopyOutputRequest with a base::UnguessableToken

content/browser/media/capture/web_contents_video_capture_device.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/media/capture/web_contents_video_capture_device.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/cursor_renderer.h"
 #include "content/browser/media/capture/web_contents_tracker.h"
 #include "content/browser/media/capture/window_activity_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
+#include "content/browser/renderer_host/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
-#include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_media_capture_id.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/capture/content/screen_capture_device_core.h"
 #include "media/capture/content/thread_safe_capture_oracle.h"
 #include "media/capture/content/video_capture_oracle.h"
 #include "media/capture/video_capture_types.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size_conversions.h"
@@ skipping 13 matching lines @@
 class FrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FrameSubscriber(media::VideoCaptureOracle::Event event_type,
                   scoped_refptr<media::ThreadSafeCaptureOracle> oracle,
                   base::WeakPtr<content::CursorRenderer> cursor_renderer,
                   base::WeakPtr<content::WindowActivityTracker> tracker)
       : event_type_(event_type),
         oracle_proxy_(std::move(oracle)),
         cursor_renderer_(cursor_renderer),
         window_activity_tracker_(tracker),
+        source_id_for_copy_request_(base::UnguessableToken::Create()),
         weak_ptr_factory_(this) {}
 
-  bool ShouldCaptureFrame(
-      const gfx::Rect& damage_rect,
-      base::TimeTicks present_time,
-      scoped_refptr<media::VideoFrame>* storage,
-      RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback*
-          deliver_frame_cb) override;
-
   static void DidCaptureFrame(
       base::WeakPtr<FrameSubscriber> frame_subscriber_,
       const media::ThreadSafeCaptureOracle::CaptureFrameCallback&
           capture_frame_cb,
       scoped_refptr<media::VideoFrame> frame,
       base::TimeTicks timestamp,
       const gfx::Rect& region_in_frame,
       bool success);
 
   bool IsUserInteractingWithContent();
 
+  // RenderWidgetHostViewFrameSubscriber implementation:
+  bool ShouldCaptureFrame(
+      const gfx::Rect& damage_rect,
+      base::TimeTicks present_time,
+      scoped_refptr<media::VideoFrame>* storage,
+      RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback*
+          deliver_frame_cb) override;
+  const base::UnguessableToken& GetSourceIdForCopyRequest() override;
+
  private:
   const media::VideoCaptureOracle::Event event_type_;
   const scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the cursor renderer.
   const base::WeakPtr<CursorRenderer> cursor_renderer_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the ui activity tracker.
   const base::WeakPtr<WindowActivityTracker> window_activity_tracker_;
+  base::UnguessableToken source_id_for_copy_request_;
   base::WeakPtrFactory<FrameSubscriber> weak_ptr_factory_;
 };
 
 // ContentCaptureSubscription is the relationship between a RenderWidgetHostView
 // whose content is updating, a subscriber that is deciding which of these
 // updates to capture (and where to deliver them to), and a callback that
 // knows how to do the capture and prepare the result for delivery.
 //
 // In practice, this means (a) installing a RenderWidgetHostFrameSubscriber in
 // the RenderWidgetHostView, to process compositor updates, and (b) occasionally
@@ skipping 134 matching lines @@
   // resumed.
   bool frame_capture_active_;
 
   // Weak pointer factory used to invalidate callbacks.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<WebContentsCaptureMachine> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsCaptureMachine);
 };
 
-bool FrameSubscriber::ShouldCaptureFrame(
-    const gfx::Rect& damage_rect,
-    base::TimeTicks present_time,
-    scoped_refptr<media::VideoFrame>* storage,
-    DeliverFrameCallback* deliver_frame_cb) {
-  TRACE_EVENT1("gpu.capture", "FrameSubscriber::ShouldCaptureFrame", "instance",
-               this);
-
-  media::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
-  if (!oracle_proxy_->ObserveEventAndDecideCapture(
-          event_type_, damage_rect, present_time, storage, &capture_frame_cb)) {
-    return false;
-  }
-
-  DCHECK(*storage);
-  DCHECK(!capture_frame_cb.is_null());
-  *deliver_frame_cb =
-      base::Bind(&FrameSubscriber::DidCaptureFrame,
-                 weak_ptr_factory_.GetWeakPtr(), capture_frame_cb, *storage);
-  return true;
-}
-
 void FrameSubscriber::DidCaptureFrame(
     base::WeakPtr<FrameSubscriber> frame_subscriber_,
     const media::ThreadSafeCaptureOracle::CaptureFrameCallback&
         capture_frame_cb,
     scoped_refptr<media::VideoFrame> frame,
     base::TimeTicks timestamp,
     const gfx::Rect& region_in_frame,
     bool success) {
   if (success) {
     // We can get a callback in the shutdown sequence for the browser main loop
@@ skipping 25 matching lines @@
         base::TimeDelta::FromMilliseconds(kMinPeriodNoAnimationMillis);
     if (ui_activity && !animation_active) {
       interactive_mode = true;
     } else if (animation_active && window_activity_tracker_) {
       window_activity_tracker_->Reset();
     }
   }
   return interactive_mode;
 }
 
+bool FrameSubscriber::ShouldCaptureFrame(
+    const gfx::Rect& damage_rect,
+    base::TimeTicks present_time,
+    scoped_refptr<media::VideoFrame>* storage,
+    DeliverFrameCallback* deliver_frame_cb) {
+  TRACE_EVENT1("gpu.capture", "FrameSubscriber::ShouldCaptureFrame", "instance",
+               this);
+
+  media::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
+  if (!oracle_proxy_->ObserveEventAndDecideCapture(
+          event_type_, damage_rect, present_time, storage, &capture_frame_cb)) {
+    return false;
+  }
+
+  DCHECK(*storage);
+  DCHECK(!capture_frame_cb.is_null());
+  *deliver_frame_cb =
+      base::Bind(&FrameSubscriber::DidCaptureFrame,
+                 weak_ptr_factory_.GetWeakPtr(), capture_frame_cb, *storage);
+  return true;
+}
+
+const base::UnguessableToken& FrameSubscriber::GetSourceIdForCopyRequest() {
+  return source_id_for_copy_request_;
+}
+
 ContentCaptureSubscription::ContentCaptureSubscription(
     base::WeakPtr<RenderWidgetHostViewBase> source_view,
     scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy,
     const CaptureCallback& capture_callback)
     : source_view_(source_view), capture_callback_(capture_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(source_view_);
 
 #if defined(USE_AURA) || defined(OS_MACOSX)
   cursor_renderer_ = CursorRenderer::Create(source_view_->GetNativeView());
@@ skipping 421 matching lines @@
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 void WebContentsVideoCaptureDevice::OnUtilizationReport(int frame_feedback_id,
                                                         double utilization) {
   core_->OnConsumerReportingUtilization(frame_feedback_id, utilization);
 }
 
 }  // namespace content