Fix partial screenshot/window screenshot when holding Alt+Tab.

ash/utility/screenshot_controller.cc

 // 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.
 
 #include "ash/utility/screenshot_controller.h"
 
 #include <cmath>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
-#include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/cursor_manager.h"
@@ skipping 29 matching lines @@
         display::Screen::GetScreen()->GetDisplayNearestPoint(location);
 
     aura::Window* root_window = Shell::GetInstance()
                                     ->window_tree_host_manager()
                                     ->GetRootWindowForDisplayId(display.id());
 
     position_client->ConvertPointFromScreen(root_window, &location);
 
     gfx::Point target_location = event->location();
     event->set_location(location);
-
-    // Ignore capture window when finding the target for located event.

[Evan Stade, 2016/10/06 16:32:34]

so I noticed this bit of code as well, which seems to also be dealing with
capture but in a different way. +oshima who wrote this. Do you remember what
this was intended to deal with? It seems unnecessary now if we just explicitly
break capture. Do you know what behavior I should test to make sure we're not
regressing something?

[oshima, 2016/10/06 20:07:53]

This is to deal with menu windows, so please do not remove.

-    aura::client::CaptureClient* original_capture_client =
-        aura::client::GetCaptureClient(root_window);
-    aura::client::SetCaptureClient(root_window, nullptr);
-
     aura::Window* selected =
         static_cast<aura::Window*>(FindTargetForEvent(root_window, event));
 
     // Restore State.
-    aura::client::SetCaptureClient(root_window, original_capture_client);
     event->set_location(target_location);
     return selected;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScreenshotWindowTargeter);
 };
 
 }  // namespace
 
@@ skipping 162 matching lines @@
     CancelScreenshotSession();
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void ScreenshotController::StartWindowScreenshotSession(
     ScreenshotDelegate* screenshot_delegate) {
   if (screenshot_delegate_) {
     DCHECK_EQ(screenshot_delegate_, screenshot_delegate);
     return;
   }
+
+  for (aura::Window* root : Shell::GetAllRootWindows()) {
+    // Since we'll be pre-handling all mouse events, break any existing
+    // captures.
+    aura::client::GetCaptureClient(root)->SetCapture(nullptr);
+    layers_[root] = base::MakeUnique<ScreenshotLayer>(
+        Shell::GetContainer(root, kShellWindowId_OverlayContainer)->layer(),
+        true);
+  }
+
   screenshot_delegate_ = screenshot_delegate;
   mode_ = WINDOW;
 
   display::Screen::GetScreen()->AddObserver(this);
-  for (aura::Window* root : Shell::GetAllRootWindows()) {
-    layers_[root] = base::MakeUnique<ScreenshotLayer>(
-        Shell::GetContainer(root, kShellWindowId_OverlayContainer)->layer(),
-        true);
-  }
   SetSelectedWindow(wm::GetActiveWindow());
 
   cursor_setter_.reset(new ScopedCursorSetter(
       Shell::GetInstance()->cursor_manager(), ui::kCursorCross));
 
   EnableMouseWarp(true);
 }
 
 void ScreenshotController::StartPartialScreenshotSession(
     ScreenshotDelegate* screenshot_delegate,
     bool draw_overlay_immediately) {
   // Already in a screenshot session.
   if (screenshot_delegate_) {
     DCHECK_EQ(screenshot_delegate_, screenshot_delegate);
     return;
   }
 
+  for (aura::Window* root : Shell::GetAllRootWindows()) {
+    // Since we'll be pre-handling all mouse events, break any existing
+    // captures.
+    aura::client::GetCaptureClient(root)->SetCapture(nullptr);
+    layers_[root] = base::MakeUnique<ScreenshotLayer>(
+        Shell::GetContainer(root, kShellWindowId_OverlayContainer)->layer(),
+        draw_overlay_immediately);
+  }
+
   screenshot_delegate_ = screenshot_delegate;
   mode_ = PARTIAL;
   display::Screen::GetScreen()->AddObserver(this);
-  for (aura::Window* root : Shell::GetAllRootWindows()) {
-    layers_[root] = base::MakeUnique<ScreenshotLayer>(
-        Shell::GetContainer(root, kShellWindowId_OverlayContainer)->layer(),
-        draw_overlay_immediately);
-  }
 
   if (!pen_events_only_) {
     cursor_setter_.reset(new ScopedCursorSetter(
         Shell::GetInstance()->cursor_manager(), ui::kCursorCross));
   }
 
   EnableMouseWarp(false);
 }
 
 void ScreenshotController::CancelScreenshotSession() {
@@ skipping 133 matching lines @@
       event->StopPropagation();
     } else if (event->key_code() == ui::VKEY_RETURN && mode_ == WINDOW) {
       CompleteWindowScreenshot();
       event->StopPropagation();
     }
   }
 
   // Stop all key events except if the user is using a pointer, in which case
   // they should be able to continue manipulating the screen.
   if (!pen_events_only_)
     event->StopPropagation();

[oshima, 2016/10/06 20:07:53]

how about passing through the event that is required to close the alt-tab when
necessary?

[Evan Stade, 2016/10/06 20:21:19]

I don't think that would fix the tab dragging case, would it? And what would
that look like? Don't stop propagation if it's a release of the alt key? That
seems fairly fragile and specific to this particular problem. If you don't stop
propagation of any key release, that seems likely to cause bad things to happen.

 }
 
 void ScreenshotController::OnMouseEvent(ui::MouseEvent* event) {
   if (!screenshot_delegate_ || !ShouldProcessEvent(event->pointer_details()))
     return;
   switch (mode_) {
     case NONE:
       NOTREACHED();
       break;
     case WINDOW:
@@ skipping 86 matching lines @@
 
 void ScreenshotController::OnDisplayMetricsChanged(
     const display::Display& display,
     uint32_t changed_metrics) {}
 
 void ScreenshotController::OnWindowDestroying(aura::Window* window) {
   SetSelectedWindow(nullptr);
 }
 
 }  // namespace ash