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),
+    : is_root_(false),
+      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();

[Ben Goodger (Google), 2011/09/21 04:15:21]

Can you maybe move the FocusManager code above into the root's destroying
function too?

+  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.
   if (delegate_)
@@ skipping 11 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 45 matching lines @@
   SchedulePaintInRect(gfx::Rect());
 
   ui::Layer* parent_layer = child->layer()->parent();
   parent_layer->Remove(child->layer());
   parent_layer->Add(child->layer());
 }
 
 void Window::AddChild(Window* child) {
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
+  DCHECK(!child->is_root_);
   child->parent_ = this;
   layer_->Add(child->layer_.get());
   children_.push_back(child);
 }
 
 void Window::RemoveChild(Window* child) {
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   child->parent_ = NULL;
   layer_->Remove(child->layer_.get());
@@ skipping 44 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;
+}
+
+Window::Window(WindowDelegate* delegate, bool is_root)
+    : is_root_(is_root),
+      delegate_(delegate),
+      visibility_(VISIBILITY_HIDDEN),
+      parent_(NULL),
+      id_(-1),
+      user_data_(NULL) {
+}
+
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds_.width(), bounds_.height()));
 }
 
+RootWindow* Window::GetRoot() {

[Ben Goodger (Google), 2011/09/21 04:15:21]

rather than adding this state, how about a virtual function that crawls up, like
GetFocusManager, that RootWindow overrides.

+  Window* parent = this;
+  while (parent && !parent->is_root_)
+    parent = parent->parent_;
+  return static_cast<RootWindow*>(parent);
+}
+
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura