Implement all resolution change policies for desktop and tab capture.

content/browser/media/capture/web_contents_tracker.h

 // Copyright (c) 2013 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.
 //
 // Given a starting render_process_id and main_render_frame_id, the
 // WebContentsTracker tracks changes to the active RenderFrameHost tree during
 // the lifetime of a WebContents instance.  This is used when mirroring tab
 // video and audio so that user navigations, crashes, iframes, etc., during a
 // tab's lifetime allow the capturing code to remain active on the
 // current/latest render frame tree.
@@ skipping 24 matching lines @@
  public:
   // If |track_fullscreen_rwh| is true, the ChangeCallback will be run when a
   // WebContents shows/destroys a fullscreen RenderWidgetHost view.  If false,
   // fullscreen events are ignored.  Specify true for video tab capture and
   // false for audio tab capture.
   explicit WebContentsTracker(bool track_fullscreen_rwh);
 
   // Callback to indicate a new RenderWidgetHost should be targeted for capture.
   // This is also invoked with NULL to indicate tracking will not continue
   // (i.e., the WebContents instance was not found or has been destroyed).
   typedef base::Callback<void(RenderWidgetHost* rwh)> ChangeCallback;

[Wez, 2015/05/14 01:44:55]

As noted in the MaybeDoResizeCallback() impl, this doesn't look safe - in the
case that Start() etc are called on a thread other than the UI thread,
ChangeCallbacks are dispatched asynchronously, so there is no guarantee that the
RWH still exists by the time that the callback task is run.

The callback signature should therefore take a void* rather than a typed
pointer, to protect against recipients accidentally trying to use the pointer to
actually access RWH members.

Looking at the WebContentsCaptureMachine, it looks like it's already (ab)using
the RWH pointer in the callback to poke into RWH structures, so that will need
to be fixed. :(

[miu, 2015/05/14 21:12:27]

Agreed about the safety concern.  See my response to your other comment.

I think the remainder of your comment here was based on your assumption that
dereferencing the RWH pointer is always dangerous.  I've added code comments
here to explain when it is safe and confirmed that it is really only being used
when safe to do so.

 
   // Start tracking.  The last-known |render_process_id| and
   // |main_render_frame_id| are provided, and |callback| will be run once to
   // indicate the current capture target (this may occur during the invocation
   // of Start(), or in the future).  The callback will be invoked on the same
   // thread calling Start().
   virtual void Start(int render_process_id, int main_render_frame_id,
                      const ChangeCallback& callback);
 
   // Stop tracking.  Once this method returns, the callback is guaranteed not to
   // be invoked again.
   virtual void Stop();
 
   // Current target.  This must only be called on the UI BrowserThread.
   RenderWidgetHost* GetTargetRenderWidgetHost() const;
 
+  // Set a callback that is run whenever the main frame of the WebContents is
+  // resized.  The callback will be invoked on the same thread that called this
+  // method, which should be the same thread that calls Start()/Stop().  Calling

[Wez, 2015/05/14 01:44:55]

nit: Suggest clarifying that this must be called from the same thread as
Start/Stop, and _then_ that the |callback| will be called on that thread.

[miu, 2015/05/14 21:12:27]

Done.

+  // the Stop() method guarantees the callback will never be invoked again.
+  void SetResizeChangeCallback(const ChangeCallback& callback);
+
  protected:
   friend class base::RefCountedThreadSafe<WebContentsTracker>;
   ~WebContentsTracker() override;
 
  private:
   // Determine the target RenderWidgetHost and, if different from that last
   // reported, runs the ChangeCallback on the appropriate thread.  If
   // |force_callback_run| is true, the ChangeCallback is run even if the
   // RenderWidgetHost has not changed.
   void OnPossibleTargetChange(bool force_callback_run);
 
   // Called on the thread that Start()/Stop() are called on.  Checks whether the
   // callback is still valid and, if so, runs it.
   void MaybeDoCallback(RenderWidgetHost* rwh);
 
+  // Called on the thread that Start()/Stop() are called on.  Checks whether the
+  // callback is still valid and, if so, runs it to indicate the main frame has
+  // changed in size.
+  void MaybeDoResizeCallback(RenderWidgetHost* rwh);
+
   // Look-up the current WebContents instance associated with the given
   // |render_process_id| and |main_render_frame_id| and begin observing it.
   void StartObservingWebContents(int render_process_id,
                                  int main_render_frame_id);
 
   // WebContentsObserver overrides: According to web_contents_observer.h, these
   // two method overrides are all that is necessary to track the set of active
   // RenderFrameHosts.
   void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
   void RenderFrameHostChanged(RenderFrameHost* old_host,
                               RenderFrameHost* new_host) override;
 
+  // WebContentsObserver override to notify the client that the source size has
+  // changed.
+  void MainFrameWasResized(bool width_changed) override;
+
   // WebContentsObserver override to notify the client that the capture target
   // has been permanently lost.
   void WebContentsDestroyed() override;
 
   // WebContentsObserver overrides to notify the client that the capture target
   // may have changed due to a separate fullscreen widget shown/destroyed.
   void DidShowFullscreenWidget(int routing_id) override;
   void DidDestroyFullscreenWidget(int routing_id) override;
 
   // If true, the client is interested in the showing/destruction of fullscreen
   // RenderWidgetHosts.
   const bool track_fullscreen_rwh_;
 
   // TaskRunner corresponding to the thread that called Start().
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Callback to run when the target RenderWidgetHost has changed.
   ChangeCallback callback_;
 
   // Pointer to the RenderWidgetHost provided in the last run of |callback_|.
   // This is used to eliminate duplicate callback runs.
   RenderWidgetHost* last_target_;
 
+  // Callback to run when the target RenderWidgetHost has resized.
+  ChangeCallback resize_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(WebContentsTracker);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEDIA_CAPTURE_WEB_CONTENTS_TRACKER_H_