ui/wm/core/capture_controller.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/wm/core/capture_controller.h"
   6
   7 #include "ui/aura/window.h"
   8 #include "ui/aura/window_event_dispatcher.h"
   9 #include "ui/aura/window_tree_host.h"
  10
  11 namespace wm {
  12
  13 ////////////////////////////////////////////////////////////////////////////////
  14 // CaptureController, public:
  15
  16 void CaptureController::Attach(aura::Window* root) {
  17   DCHECK_EQ(0u, delegates_.count(root));
  18   delegates_[root] = root->GetHost()->dispatcher();
  19   aura::client::SetCaptureClient(root, this);
  20 }
  21
  22 void CaptureController::Detach(aura::Window* root) {
  23   delegates_.erase(root);
  24   aura::client::SetCaptureClient(root, nullptr);
  25 }
  26
  27 ////////////////////////////////////////////////////////////////////////////////
  28 // CaptureController, aura::client::CaptureClient implementation:
  29
  30 void CaptureController::SetCapture(aura::Window* new_capture_window) {
  31   if (capture_window_ == new_capture_window)
  32     return;
  33
  34   // Make sure window has a root window.
  35   DCHECK(!new_capture_window || new_capture_window->GetRootWindow());
  36   DCHECK(!capture_window_ || capture_window_->GetRootWindow());
  37
  38   aura::Window* old_capture_window = capture_window_;
  39   aura::client::CaptureDelegate* old_capture_delegate = capture_delegate_;
  40
  41   // Copy the map in case it's modified out from under us.
  42   std::map<aura::Window*, aura::client::CaptureDelegate*> delegates =
  43       delegates_;
  44
  45   // If we're starting a new capture, cancel all touches that aren't
  46   // targeted to the capturing window.
  47   if (new_capture_window)
  48     ui::GestureRecognizer::Get()->CancelActiveTouchesExcept(new_capture_window);
  49
  50   capture_window_ = new_capture_window;
  51   aura::Window* capture_root_window =
  52       capture_window_ ? capture_window_->GetRootWindow() : nullptr;
  53   capture_delegate_ = delegates_.find(capture_root_window) == delegates_.end()
  54                           ? nullptr
  55                           : delegates_[capture_root_window];
  56
  57   for (const auto& it : delegates)
  58     it.second->UpdateCapture(old_capture_window, new_capture_window);
  59
  60   if (capture_delegate_ != old_capture_delegate) {
  61     if (old_capture_delegate)
  62       old_capture_delegate->ReleaseNativeCapture();
  63     if (capture_delegate_)
  64       capture_delegate_->SetNativeCapture();
  65   }
  66 }
  67
  68 void CaptureController::ReleaseCapture(aura::Window* window) {
  69   if (capture_window_ != window)
  70     return;
  71   SetCapture(nullptr);
  72 }
  73
  74 aura::Window* CaptureController::GetCaptureWindow() {
  75   return capture_window_;
  76 }
  77
  78 aura::Window* CaptureController::GetGlobalCaptureWindow() {
  79   return capture_window_;
  80 }
  81
  82 ////////////////////////////////////////////////////////////////////////////////
  83 // CaptureController, private:
  84
  85 CaptureController::CaptureController()
  86     : capture_window_(nullptr),
  87       capture_delegate_(nullptr) {
  88 }
  89
  90 CaptureController::~CaptureController() {
  91 }
  92
  93 ////////////////////////////////////////////////////////////////////////////////
  94 // ScopedCaptureClient:
  95
  96 // static
  97 CaptureController* ScopedCaptureClient::capture_controller_ = nullptr;
  98
  99 ScopedCaptureClient::ScopedCaptureClient(aura::Window* root)
 100     : root_window_(root) {
 101   root->AddObserver(this);
 102   if (!capture_controller_)
 103     capture_controller_ = new CaptureController;
 104   capture_controller_->Attach(root);
 105 }
 106
 107 ScopedCaptureClient::~ScopedCaptureClient() {
 108   Shutdown();
 109 }
 110
 111 // static
 112 bool ScopedCaptureClient::IsActive() {
 113   return capture_controller_ && capture_controller_->is_active();
 114 }
 115
 116 void ScopedCaptureClient::OnWindowDestroyed(aura::Window* window) {
 117   DCHECK_EQ(window, root_window_);
 118   Shutdown();
 119 }
 120
 121 void ScopedCaptureClient::Shutdown() {
 122   if (!root_window_)
 123     return;
 124
 125   root_window_->RemoveObserver(this);
 126   capture_controller_->Detach(root_window_);
 127   if (!capture_controller_->is_active()) {
 128     delete capture_controller_;
 129     capture_controller_ = nullptr;
 130   }
 131   root_window_ = nullptr;
 132 }
 133
 134 ///////////////////////////////////////////////////////////////////////////////
 135 // CaptureController::TestApi
 136
 137 void ScopedCaptureClient::TestApi::SetDelegate(
 138     aura::client::CaptureDelegate* delegate) {
 139   client_->capture_controller_->delegates_[client_->root_window_] = delegate;
 140 }
 141
 142 }  // namespace wm