Window capture stop draw cursor when it points to the hidden content.

content/browser/media/capture/aura_window_capture_machine.cc

 // Copyright 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.
 
 #include "content/browser/media/capture/aura_window_capture_machine.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 12 matching lines @@
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursors_aura.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
+#include "ui/wm/public/activation_client.h"
 
 namespace content {
 
 namespace {
 
 int clip_byte(int x) {
   return std::max(0, std::min(x, 255));
 }
 
 int alpha_blend(int alpha, int src, int dst) {
@@ skipping 363 matching lines @@
 gfx::Point AuraWindowCaptureMachine::UpdateCursorState(
     const gfx::Rect& region_in_frame) {
   const gfx::Rect window_bounds = desktop_window_->GetBoundsInScreen();
   gfx::Point cursor_position = aura::Env::GetInstance()->last_mouse_location();
   if (!window_bounds.Contains(cursor_position)) {
     // Return early if there is no need to draw the cursor.
     ClearCursorState();
     return gfx::Point();
   }
 
+  // Return early if the target content pointed by the mouse is hidden.
+  aura::client::ActivationClient* activation_client =
+      aura::client::GetActivationClient(desktop_window_->GetRootWindow());
+  DCHECK(activation_client);
+  aura::Window* active_window = activation_client->GetActiveWindow();
+  DCHECK(active_window);
+  if (active_window != desktop_window_) {
+    if (active_window->GetBoundsInScreen().Contains(cursor_position)) {

[miu, 2015/10/19 19:49:47]

This mostly works.  It wouldn't if there were TWO windows on top of the window
being mirrored.  ;-)

However, I think you're on the right track here.  IMO, it would be reasonable to
simply shut off the cursor if the mirrored window is not the currently-active
window (or a parent of it).  Meaning, just do:

  if (!desktop_window_->Contains(active_window)) {
    ClearCursorState();
    return gfx::Point();
  }

BTW--After doing this, you don't need the DCHECK(active_window) statement since
the Window::Contains() will safely handle null pointers.

[xjz, 2015/10/20 00:03:21]

Done.

+      ClearCursorState();
+      return gfx::Point();
+    }
+  }
+
   gfx::NativeCursor cursor = desktop_window_->GetHost()->last_cursor();
   gfx::Point cursor_hot_point;
   if (last_cursor_ != cursor ||
       window_size_when_cursor_last_updated_ != window_bounds.size()) {
     SkBitmap cursor_bitmap;
     if (ui::GetCursorBitmap(cursor, &cursor_bitmap, &cursor_hot_point)) {
       const int scaled_width = cursor_bitmap.width() *
           region_in_frame.width() / window_bounds.width();
       const int scaled_height = cursor_bitmap.height() *
           region_in_frame.height() / window_bounds.height();
@@ skipping 75 matching lines @@
   // TODO(miu): The CopyOutputRequest should be made earlier, at WillCommit().
   // http://crbug.com/492839
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&AuraWindowCaptureMachine::Capture, weak_factory_.GetWeakPtr(),
                  true));
 }
 
 }  // namespace content