mus: Implement Window Server Capture

components/mus/public/cpp/lib/window.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 "components/mus/public/cpp/window.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 355 matching lines @@
     tree_client()->SetWindowTextInputState(id_, std::move(state));
 }
 
 void Window::SetImeVisibility(bool visible, mojo::TextInputStatePtr state) {
   // SetImeVisibility() shouldn't be used if the window is not editable.
   DCHECK(state.is_null() || state->type != mojo::TextInputType::NONE);
   if (connection_)
     tree_client()->SetImeVisibility(id_, visible, std::move(state));
 }
 
+void Window::SetCapture() {
+  if (connection_)
+    tree_client()->SetCapture(this);
+  LocalSetCapture(true);
+}
+
+void Window::ReleaseCapture() {
+  if (connection_)
+    tree_client()->ReleaseCapture(this);
+  LocalSetCapture(false);
+}
+
 void Window::SetFocus() {
   if (connection_ && IsDrawn())
     tree_client()->SetFocus(this);
 }
 
 bool Window::HasFocus() const {
   return connection_ && connection_->GetFocusedWindow() == this;
 }
 
 void Window::SetCanFocus(bool can_focus) {
@@ skipping 90 matching lines @@
 
 Window::Window(WindowTreeConnection* connection, Id id)
     : connection_(connection),
       id_(id),
       parent_(nullptr),
       stacking_target_(nullptr),
       transient_parent_(nullptr),
       input_event_handler_(nullptr),
       viewport_metrics_(CreateEmptyViewportMetrics()),
       visible_(false),
+      has_capture_(false),
       cursor_id_(mojom::Cursor::CURSOR_NULL),
       drawn_(false) {}
 
 WindowTreeClientImpl* Window::tree_client() {
   return static_cast<WindowTreeClientImpl*>(connection_);
 }
 
 void Window::SetSharedPropertyInternal(const std::string& name,
                                        const std::vector<uint8_t>* value) {
   if (!OwnsWindowOrIsRoot(this))
@@ skipping 86 matching lines @@
 
 void Window::LocalSetBounds(const gfx::Rect& old_bounds,
                             const gfx::Rect& new_bounds) {
   // If this client owns the window, then it should be the only one to change
   // the bounds.
   DCHECK(!OwnsWindow(connection_, this) || old_bounds == bounds_);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   bounds_ = new_bounds;
 }
 
+void Window::LocalSetCapture(bool capture) {
+  has_capture_ = capture;
+}
+
 void Window::LocalSetClientArea(
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   const std::vector<gfx::Rect> old_additional_client_areas =
       additional_client_areas_;
   const gfx::Insets old_client_area = client_area_;
   client_area_ = new_client_area;
   additional_client_areas_ = additional_client_areas;
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowClientAreaChanged(this, old_client_area,
@@ skipping 211 matching lines @@
     notifier->NotifyWindowReordered();
 
   return true;
 }
 
 // static
 Window** Window::GetStackingTarget(Window* window) {
   return &window->stacking_target_;
 }
 }  // namespace mus