Allow the user to cancel the capture region action, and show its active status in the tray.

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"
@@ skipping 227 matching lines @@
       root_window_(nullptr),
       selected_(nullptr),
       screenshot_delegate_(nullptr) {
   // Keep this here and don't move it to StartPartialScreenshotSession(), as it
   // needs to be pre-pended by MouseCursorEventFilter in Shell::Init().
   Shell::GetInstance()->PrependPreTargetHandler(this);
 }
 
 ScreenshotController::~ScreenshotController() {
   if (screenshot_delegate_)
-    Cancel();
+    CancelScreenshotSession();
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void ScreenshotController::StartWindowScreenshotSession(
     ScreenshotDelegate* screenshot_delegate) {
   if (screenshot_delegate_) {
     DCHECK_EQ(screenshot_delegate_, screenshot_delegate);
     return;
   }
   screenshot_delegate_ = screenshot_delegate;
@@ skipping 32 matching lines @@
   }
 
   if (!pen_events_only_) {
     cursor_setter_.reset(new ScopedCursorSetter(
         Shell::GetInstance()->cursor_manager(), ui::kCursorCross));
   }
 
   EnableMouseWarp(false);
 }
 
+void ScreenshotController::CancelScreenshotSession() {
+  mode_ = NONE;
+  pen_events_only_ = false;
+  root_window_ = nullptr;
+  SetSelectedWindow(nullptr);
+  screenshot_delegate_ = nullptr;
+  display::Screen::GetScreen()->RemoveObserver(this);
+  base::STLDeleteValues(&layers_);
+  cursor_setter_.reset();
+  EnableMouseWarp(true);
+}
+
 void ScreenshotController::MaybeStart(const ui::LocatedEvent& event) {
   aura::Window* current_root =
       static_cast<aura::Window*>(event.target())->GetRootWindow();
   if (root_window_) {
     // It's already started. This can happen when the second finger touches
     // the screen, or combination of the touch and mouse. We should grab the
     // partial screenshot instead of restarting.
     if (current_root == root_window_) {
       Update(event);
       CompletePartialScreenshot();
     }
   } else {
     root_window_ = current_root;
     start_position_ = event.root_location();
     if (!pen_events_only_) {
       // ScopedCursorSetter must be reset first to make sure that its dtor is
       // called before ctor is called.
       cursor_setter_.reset();
       cursor_setter_.reset(new ScopedCursorSetter(
           Shell::GetInstance()->cursor_manager(), ui::kCursorNone));
     }
     Update(event);
   }
 }
 
 void ScreenshotController::CompleteWindowScreenshot() {
   if (selected_)
     screenshot_delegate_->HandleTakeWindowScreenshot(selected_);
-  Cancel();
+  CancelScreenshotSession();
 }
 
 void ScreenshotController::CompletePartialScreenshot() {
   if (!root_window_) {
     // If we received a released event before we ever got a pressed event
     // (resulting in setting |root_window_|), we just return without canceling
     // to keep the screenshot session active waiting for the next press.
     //
     // This is to avoid a crash that used to happen when we start the screenshot
     // session while the mouse is pressed and then release without moving the
     // mouse. crbug.com/581432.
     return;
   }
 
   DCHECK(layers_.count(root_window_));
   const gfx::Rect& region = layers_.at(root_window_)->region();
   if (!region.IsEmpty()) {
     screenshot_delegate_->HandleTakePartialScreenshot(
         root_window_, gfx::IntersectRects(root_window_->bounds(), region));
   }
-  Cancel();
-}
-
-void ScreenshotController::Cancel() {
-  mode_ = NONE;
-  pen_events_only_ = false;
-  root_window_ = nullptr;
-  SetSelectedWindow(nullptr);
-  screenshot_delegate_ = nullptr;
-  display::Screen::GetScreen()->RemoveObserver(this);
-  base::STLDeleteValues(&layers_);
-  cursor_setter_.reset();
-  EnableMouseWarp(true);
+  CancelScreenshotSession();
 }
 
 void ScreenshotController::Update(const ui::LocatedEvent& event) {
   // Update may happen without MaybeStart() if the partial screenshot session
   // starts when dragging.
   if (!root_window_)
     MaybeStart(event);
   DCHECK(layers_.find(root_window_) != layers_.end());
 
   ScreenshotLayer* layer = layers_.at(root_window_);
@@ skipping 43 matching lines @@
   return !pen_events_only_ ||
          pointer_details.pointer_type == ui::EventPointerType::POINTER_TYPE_PEN;
 }
 
 void ScreenshotController::OnKeyEvent(ui::KeyEvent* event) {
   if (!screenshot_delegate_)
     return;
 
   if (event->type() == ui::ET_KEY_RELEASED) {
     if (event->key_code() == ui::VKEY_ESCAPE) {
-      Cancel();
+      CancelScreenshotSession();
       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_)
@@ skipping 78 matching lines @@
           break;
       }
       break;
   }
   event->StopPropagation();
 }
 
 void ScreenshotController::OnDisplayAdded(const display::Display& new_display) {
   if (!screenshot_delegate_)
     return;
-  Cancel();
+  CancelScreenshotSession();
 }
 
 void ScreenshotController::OnDisplayRemoved(
     const display::Display& old_display) {
   if (!screenshot_delegate_)
     return;
-  Cancel();
+  CancelScreenshotSession();
 }
 
 void ScreenshotController::OnDisplayMetricsChanged(
     const display::Display& display,
     uint32_t changed_metrics) {}
 
 void ScreenshotController::OnWindowDestroying(aura::Window* window) {
   SetSelectedWindow(nullptr);
 }
 
 }  // namespace ash