Wires up mouse capture code for aura.

ui/aura/window.cc

 // Copyright (c) 2011 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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 
 namespace aura {
 
+using internal::RootWindow;
+
 Window::Window(WindowDelegate* delegate)
     : delegate_(delegate),
       visibility_(VISIBILITY_HIDDEN),
       parent_(NULL),
       id_(-1),
       user_data_(NULL) {
 }
 
 Window::~Window() {
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying();
 
-  // Update the FocusManager in case we were focused. This must be done before
-  // we are removed from the hierarchy otherwise we won't be able to find the
-  // FocusManager.
-  internal::FocusManager* focus_manager = GetFocusManager();
-  if (focus_manager && focus_manager->focused_window() == this)
-    focus_manager->SetFocusedWindow(NULL);
+  // Let the root know so that it can remove any references to us.
+  RootWindow* root = GetRoot();
+  if (root)
+    root->WindowDestroying(this);
 
   // Then destroy the children.
   while (!children_.empty()) {
     Window* child = children_[0];
     delete child;
     // Deleting the child so remove it from out children_ list.
     DCHECK(std::find(children_.begin(), children_.end(), child) ==
            children_.end());
   }
   // And let the delegate do any post cleanup.
@@ skipping 12 matching lines @@
 }
 
 void Window::SetVisibility(Visibility visibility) {
   if (visibility_ == visibility)
     return;
 
   visibility_ = visibility;
   layer_->set_visible(visibility_ != VISIBILITY_HIDDEN);
   if (layer_->visible())
     SchedulePaint();
+  if (visibility_ != VISIBILITY_SHOWN)
+    ReleaseCapture();
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   layout_manager_.reset(layout_manager);
 }
 
 void Window::SetBounds(const gfx::Rect& bounds, int anim_ms) {
   // TODO: support anim_ms
   // TODO: funnel this through the Desktop.
   bool was_move = bounds_.size() == bounds.size();
@@ skipping 109 matching lines @@
         return handler;
     }
   }
   return delegate_ ? this : NULL;
 }
 
 internal::FocusManager* Window::GetFocusManager() {
   return parent_ ? parent_->GetFocusManager() : NULL;
 }
 
+void Window::SetCapture() {
+  if (visibility_ != VISIBILITY_SHOWN)
+    return;
+
+  RootWindow* root = GetRoot();
+  if (!root)
+    return;
+
+  root->SetCapture(this);
+}
+
+void Window::ReleaseCapture() {
+  RootWindow* root = GetRoot();
+  if (!root)
+    return;
+
+  root->ReleaseCapture(this);
+}
+
+bool Window::HasCapture() {
+  RootWindow* root = GetRoot();
+  return root && root->capture_window() == this;
+}
+
+internal::RootWindow* Window::GetRoot() {
+  return parent_ ? parent_->GetRoot() : NULL;
+}
+
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds_.width(), bounds_.height()));
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura