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/aura/window.h"
6
7#include <algorithm>
8
9#include "base/bind.h"
10#include "base/bind_helpers.h"
11#include "base/callback.h"
12#include "base/logging.h"
13#include "base/strings/string_number_conversions.h"
14#include "base/strings/string_util.h"
15#include "base/strings/stringprintf.h"
16#include "ui/aura/client/capture_client.h"
17#include "ui/aura/client/cursor_client.h"
18#include "ui/aura/client/event_client.h"
19#include "ui/aura/client/focus_client.h"
20#include "ui/aura/client/screen_position_client.h"
21#include "ui/aura/client/visibility_client.h"
22#include "ui/aura/client/window_stacking_client.h"
23#include "ui/aura/env.h"
24#include "ui/aura/layout_manager.h"
25#include "ui/aura/window_delegate.h"
26#include "ui/aura/window_event_dispatcher.h"
27#include "ui/aura/window_observer.h"
28#include "ui/aura/window_tracker.h"
29#include "ui/aura/window_tree_host.h"
30#include "ui/compositor/compositor.h"
31#include "ui/compositor/layer.h"
32#include "ui/events/event_target_iterator.h"
33#include "ui/gfx/canvas.h"
34#include "ui/gfx/path.h"
35#include "ui/gfx/scoped_canvas.h"
36#include "ui/gfx/screen.h"
37
38namespace aura {
39
40namespace {
41
42ui::LayerType WindowLayerTypeToUILayerType(WindowLayerType window_layer_type) {
43  switch (window_layer_type) {
44    case WINDOW_LAYER_NONE:
45      break;
46    case WINDOW_LAYER_NOT_DRAWN:
47      return ui::LAYER_NOT_DRAWN;
48    case WINDOW_LAYER_TEXTURED:
49      return ui::LAYER_TEXTURED;
50    case WINDOW_LAYER_SOLID_COLOR:
51      return ui::LAYER_SOLID_COLOR;
52  }
53  NOTREACHED();
54  return ui::LAYER_NOT_DRAWN;
55}
56
57// Used when searching for a Window to stack relative to.
58template <class T>
59T IteratorForDirectionBegin(aura::Window* window);
60
61template <>
62Window::Windows::const_iterator IteratorForDirectionBegin(
63    aura::Window* window) {
64  return window->children().begin();
65}
66
67template <>
68Window::Windows::const_reverse_iterator IteratorForDirectionBegin(
69    aura::Window* window) {
70  return window->children().rbegin();
71}
72
73template <class T>
74T IteratorForDirectionEnd(aura::Window* window);
75
76template <>
77Window::Windows::const_iterator IteratorForDirectionEnd(aura::Window* window) {
78  return window->children().end();
79}
80
81template <>
82Window::Windows::const_reverse_iterator IteratorForDirectionEnd(
83    aura::Window* window) {
84  return window->children().rend();
85}
86
87// Depth first search for the first Window with a layer to stack relative
88// to. Starts at target. Does not descend into |ignore|.
89template <class T>
90ui::Layer* FindStackingTargetLayerDown(aura::Window* target,
91                                       aura::Window* ignore) {
92  if (target == ignore)
93    return NULL;
94
95  if (target->layer())
96    return target->layer();
97
98  for (T i = IteratorForDirectionBegin<T>(target);
99       i != IteratorForDirectionEnd<T>(target); ++i) {
100    ui::Layer* layer = FindStackingTargetLayerDown<T>(*i, ignore);
101    if (layer)
102      return layer;
103  }
104  return NULL;
105}
106
107// Depth first search through the siblings of |target||. This does not search
108// all the siblings, only those before/after |target| (depening upon the
109// template type) and ignoring |ignore|. Returns the Layer of the first Window
110// encountered with a Layer.
111template <class T>
112ui::Layer* FindStackingLayerInSiblings(aura::Window* target,
113                                       aura::Window* ignore) {
114  aura::Window* parent = target->parent();
115  for (T i = std::find(IteratorForDirectionBegin<T>(parent),
116                  IteratorForDirectionEnd<T>(parent), target);
117       i != IteratorForDirectionEnd<T>(parent); ++i) {
118    ui::Layer* layer = FindStackingTargetLayerDown<T>(*i, ignore);
119    if (layer)
120      return layer;
121  }
122  return NULL;
123}
124
125// Returns the first Window that has a Layer. This does a depth first search
126// through the descendants of |target| first, then ascends up doing a depth
127// first search through siblings of all ancestors until a Layer is found or an
128// ancestor with a layer is found. This is intended to locate a layer to stack
129// other layers relative to.
130template <class T>
131ui::Layer* FindStackingTargetLayer(aura::Window* target, aura::Window* ignore) {
132  ui::Layer* result = FindStackingTargetLayerDown<T>(target, ignore);
133  if (result)
134    return result;
135  while (target->parent()) {
136    ui::Layer* result = FindStackingLayerInSiblings<T>(target, ignore);
137    if (result)
138      return result;
139    target = target->parent();
140    if (target->layer())
141      return NULL;
142  }
143  return NULL;
144}
145
146// Does a depth first search for all descendants of |child| that have layers.
147// This stops at any descendants that have layers (and adds them to |layers|).
148void GetLayersToStack(aura::Window* child, std::vector<ui::Layer*>* layers) {
149  if (child->layer()) {
150    layers->push_back(child->layer());
151    return;
152  }
153  for (size_t i = 0; i < child->children().size(); ++i)
154    GetLayersToStack(child->children()[i], layers);
155}
156
157}  // namespace
158
159class ScopedCursorHider {
160 public:
161  explicit ScopedCursorHider(Window* window)
162      : window_(window),
163        hid_cursor_(false) {
164    if (!window_->IsRootWindow())
165      return;
166    const bool cursor_is_in_bounds = window_->GetBoundsInScreen().Contains(
167        Env::GetInstance()->last_mouse_location());
168    client::CursorClient* cursor_client = client::GetCursorClient(window_);
169    if (cursor_is_in_bounds && cursor_client &&
170        cursor_client->IsCursorVisible()) {
171      cursor_client->HideCursor();
172      hid_cursor_ = true;
173    }
174  }
175  ~ScopedCursorHider() {
176    if (!window_->IsRootWindow())
177      return;
178
179    // Update the device scale factor of the cursor client only when the last
180    // mouse location is on this root window.
181    if (hid_cursor_) {
182      client::CursorClient* cursor_client = client::GetCursorClient(window_);
183      if (cursor_client) {
184        const gfx::Display& display =
185            gfx::Screen::GetScreenFor(window_)->GetDisplayNearestWindow(
186                window_);
187        cursor_client->SetDisplay(display);
188        cursor_client->ShowCursor();
189      }
190    }
191  }
192
193 private:
194  Window* window_;
195  bool hid_cursor_;
196
197  DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
198};
199
200Window::Window(WindowDelegate* delegate)
201    : host_(NULL),
202      type_(ui::wm::WINDOW_TYPE_UNKNOWN),
203      owned_by_parent_(true),
204      delegate_(delegate),
205      parent_(NULL),
206      visible_(false),
207      id_(-1),
208      transparent_(false),
209      user_data_(NULL),
210      ignore_events_(false),
211      // Don't notify newly added observers during notification. This causes
212      // problems for code that adds an observer as part of an observer
213      // notification (such as the workspace code).
214      observers_(ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
215  set_target_handler(delegate_);
216}
217
218Window::~Window() {
219  // |layer()| can be NULL during tests, or if this Window is layerless.
220  if (layer()) {
221    if (layer()->owner() == this)
222      layer()->CompleteAllAnimations();
223    layer()->SuppressPaint();
224  }
225
226  // Let the delegate know we're in the processing of destroying.
227  if (delegate_)
228    delegate_->OnWindowDestroying(this);
229  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
230
231  // TODO(beng): See comment in window_event_dispatcher.h. This shouldn't be
232  //             necessary but unfortunately is right now due to ordering
233  //             peculiarities. WED must be notified _after_ other observers
234  //             are notified of pending teardown but before the hierarchy
235  //             is actually torn down.
236  WindowTreeHost* host = GetHost();
237  if (host)
238    host->dispatcher()->OnPostNotifiedWindowDestroying(this);
239
240  // The window should have already had its state cleaned up in
241  // WindowEventDispatcher::OnWindowHidden(), but there have been some crashes
242  // involving windows being destroyed without being hidden first. See
243  // crbug.com/342040. This should help us debug the issue. TODO(tdresser):
244  // remove this once we determine why we have windows that are destroyed
245  // without being hidden.
246  bool window_incorrectly_cleaned_up = CleanupGestureState();
247  CHECK(!window_incorrectly_cleaned_up);
248
249  // Then destroy the children.
250  RemoveOrDestroyChildren();
251
252  // The window needs to be removed from the parent before calling the
253  // WindowDestroyed callbacks of delegate and the observers.
254  if (parent_)
255    parent_->RemoveChild(this);
256
257  if (delegate_)
258    delegate_->OnWindowDestroyed(this);
259  ObserverListBase<WindowObserver>::Iterator iter(observers_);
260  for (WindowObserver* observer = iter.GetNext(); observer;
261       observer = iter.GetNext()) {
262    RemoveObserver(observer);
263    observer->OnWindowDestroyed(this);
264  }
265
266  // Clear properties.
267  for (std::map<const void*, Value>::const_iterator iter = prop_map_.begin();
268       iter != prop_map_.end();
269       ++iter) {
270    if (iter->second.deallocator)
271      (*iter->second.deallocator)(iter->second.value);
272  }
273  prop_map_.clear();
274
275  // If we have layer it will either be destroyed by |layer_owner_|'s dtor, or
276  // by whoever acquired it. We don't have a layer if Init() wasn't invoked or
277  // we are layerless.
278  if (layer())
279    layer()->set_delegate(NULL);
280  DestroyLayer();
281}
282
283void Window::Init(WindowLayerType window_layer_type) {
284  if (window_layer_type != WINDOW_LAYER_NONE) {
285    SetLayer(new ui::Layer(WindowLayerTypeToUILayerType(window_layer_type)));
286    layer()->SetVisible(false);
287    layer()->set_delegate(this);
288    UpdateLayerName();
289    layer()->SetFillsBoundsOpaquely(!transparent_);
290  }
291
292  Env::GetInstance()->NotifyWindowInitialized(this);
293}
294
295void Window::SetType(ui::wm::WindowType type) {
296  // Cannot change type after the window is initialized.
297  DCHECK(!layer());
298  type_ = type;
299}
300
301void Window::SetName(const std::string& name) {
302  name_ = name;
303
304  if (layer())
305    UpdateLayerName();
306}
307
308void Window::SetTitle(const base::string16& title) {
309  title_ = title;
310  FOR_EACH_OBSERVER(WindowObserver,
311                    observers_,
312                    OnWindowTitleChanged(this));
313}
314
315void Window::SetTransparent(bool transparent) {
316  transparent_ = transparent;
317  if (layer())
318    layer()->SetFillsBoundsOpaquely(!transparent_);
319}
320
321void Window::SetFillsBoundsCompletely(bool fills_bounds) {
322  if (layer())
323    layer()->SetFillsBoundsCompletely(fills_bounds);
324}
325
326Window* Window::GetRootWindow() {
327  return const_cast<Window*>(
328      static_cast<const Window*>(this)->GetRootWindow());
329}
330
331const Window* Window::GetRootWindow() const {
332  return IsRootWindow() ? this : parent_ ? parent_->GetRootWindow() : NULL;
333}
334
335WindowTreeHost* Window::GetHost() {
336  return const_cast<WindowTreeHost*>(const_cast<const Window*>(this)->
337      GetHost());
338}
339
340const WindowTreeHost* Window::GetHost() const {
341  const Window* root_window = GetRootWindow();
342  return root_window ? root_window->host_ : NULL;
343}
344
345void Window::Show() {
346  if (layer()) {
347    DCHECK_EQ(visible_, layer()->GetTargetVisibility());
348    // It is not allowed that a window is visible but the layers alpha is fully
349    // transparent since the window would still be considered to be active but
350    // could not be seen.
351    DCHECK(!(visible_ && layer()->GetTargetOpacity() == 0.0f));
352  }
353  SetVisible(true);
354}
355
356void Window::Hide() {
357  // RootWindow::OnVisibilityChanged will call ReleaseCapture.
358  SetVisible(false);
359}
360
361bool Window::IsVisible() const {
362  // Layer visibility can be inconsistent with window visibility, for example
363  // when a Window is hidden, we want this function to return false immediately
364  // after, even though the client may decide to animate the hide effect (and
365  // so the layer will be visible for some time after Hide() is called).
366  for (const Window* window = this; window; window = window->parent()) {
367    if (!window->visible_)
368      return false;
369    if (window->layer())
370      return window->layer()->IsDrawn();
371  }
372  return false;
373}
374
375gfx::Rect Window::GetBoundsInRootWindow() const {
376  // TODO(beng): There may be a better way to handle this, and the existing code
377  //             is likely wrong anyway in a multi-display world, but this will
378  //             do for now.
379  if (!GetRootWindow())
380    return bounds();
381  gfx::Point origin = bounds().origin();
382  ConvertPointToTarget(parent_, GetRootWindow(), &origin);
383  return gfx::Rect(origin, bounds().size());
384}
385
386gfx::Rect Window::GetBoundsInScreen() const {
387  gfx::Rect bounds(GetBoundsInRootWindow());
388  const Window* root = GetRootWindow();
389  if (root) {
390    aura::client::ScreenPositionClient* screen_position_client =
391        aura::client::GetScreenPositionClient(root);
392    if (screen_position_client) {
393      gfx::Point origin = bounds.origin();
394      screen_position_client->ConvertPointToScreen(root, &origin);
395      bounds.set_origin(origin);
396    }
397  }
398  return bounds;
399}
400
401void Window::SetTransform(const gfx::Transform& transform) {
402  if (!layer()) {
403    // Transforms aren't supported on layerless windows.
404    NOTREACHED();
405    return;
406  }
407  FOR_EACH_OBSERVER(WindowObserver, observers_,
408                    OnWindowTransforming(this));
409  layer()->SetTransform(transform);
410  FOR_EACH_OBSERVER(WindowObserver, observers_,
411                    OnWindowTransformed(this));
412  NotifyAncestorWindowTransformed(this);
413}
414
415void Window::SetLayoutManager(LayoutManager* layout_manager) {
416  if (layout_manager == layout_manager_)
417    return;
418  layout_manager_.reset(layout_manager);
419  if (!layout_manager)
420    return;
421  // If we're changing to a new layout manager, ensure it is aware of all the
422  // existing child windows.
423  for (Windows::const_iterator it = children_.begin();
424       it != children_.end();
425       ++it)
426    layout_manager_->OnWindowAddedToLayout(*it);
427}
428
429scoped_ptr<ui::EventTargeter>
430Window::SetEventTargeter(scoped_ptr<ui::EventTargeter> targeter) {
431  scoped_ptr<ui::EventTargeter> old_targeter = targeter_.Pass();
432  targeter_ = targeter.Pass();
433  return old_targeter.Pass();
434}
435
436void Window::SetBounds(const gfx::Rect& new_bounds) {
437  if (parent_ && parent_->layout_manager())
438    parent_->layout_manager()->SetChildBounds(this, new_bounds);
439  else {
440    // Ensure we don't go smaller than our minimum bounds.
441    gfx::Rect final_bounds(new_bounds);
442    if (delegate_) {
443      const gfx::Size& min_size = delegate_->GetMinimumSize();
444      final_bounds.set_width(std::max(min_size.width(), final_bounds.width()));
445      final_bounds.set_height(std::max(min_size.height(),
446                                       final_bounds.height()));
447    }
448    SetBoundsInternal(final_bounds);
449  }
450}
451
452void Window::SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen,
453                               const gfx::Display& dst_display) {
454  Window* root = GetRootWindow();
455  if (root) {
456    gfx::Point origin = new_bounds_in_screen.origin();
457    aura::client::ScreenPositionClient* screen_position_client =
458        aura::client::GetScreenPositionClient(root);
459    screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
460    return;
461  }
462  SetBounds(new_bounds_in_screen);
463}
464
465gfx::Rect Window::GetTargetBounds() const {
466  if (!layer())
467    return bounds();
468
469  if (!parent_ || parent_->layer())
470    return layer()->GetTargetBounds();
471
472  // We have a layer but our parent (who is valid) doesn't. This means the
473  // coordinates of the layer are relative to the first ancestor with a layer;
474  // convert to be relative to parent.
475  gfx::Vector2d offset;
476  const aura::Window* ancestor_with_layer =
477      parent_->GetAncestorWithLayer(&offset);
478  if (!ancestor_with_layer)
479    return layer()->GetTargetBounds();
480
481  gfx::Rect layer_target_bounds = layer()->GetTargetBounds();
482  layer_target_bounds -= offset;
483  return layer_target_bounds;
484}
485
486void Window::SchedulePaintInRect(const gfx::Rect& rect) {
487  if (!layer() && parent_) {
488    // Notification of paint scheduled happens for the window with a layer.
489    gfx::Rect parent_rect(bounds().size());
490    parent_rect.Intersect(rect);
491    if (!parent_rect.IsEmpty()) {
492      parent_rect.Offset(bounds().origin().OffsetFromOrigin());
493      parent_->SchedulePaintInRect(parent_rect);
494    }
495  } else if (layer()) {
496    layer()->SchedulePaint(rect);
497  }
498}
499
500void Window::StackChildAtTop(Window* child) {
501  if (children_.size() <= 1 || child == children_.back())
502    return;  // In the front already.
503  StackChildAbove(child, children_.back());
504}
505
506void Window::StackChildAbove(Window* child, Window* target) {
507  StackChildRelativeTo(child, target, STACK_ABOVE);
508}
509
510void Window::StackChildAtBottom(Window* child) {
511  if (children_.size() <= 1 || child == children_.front())
512    return;  // At the bottom already.
513  StackChildBelow(child, children_.front());
514}
515
516void Window::StackChildBelow(Window* child, Window* target) {
517  StackChildRelativeTo(child, target, STACK_BELOW);
518}
519
520void Window::AddChild(Window* child) {
521  WindowObserver::HierarchyChangeParams params;
522  params.target = child;
523  params.new_parent = this;
524  params.old_parent = child->parent();
525  params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
526  NotifyWindowHierarchyChange(params);
527
528  Window* old_root = child->GetRootWindow();
529
530  DCHECK(std::find(children_.begin(), children_.end(), child) ==
531      children_.end());
532  if (child->parent())
533    child->parent()->RemoveChildImpl(child, this);
534
535  gfx::Vector2d offset;
536  aura::Window* ancestor_with_layer = GetAncestorWithLayer(&offset);
537
538  child->parent_ = this;
539
540  if (ancestor_with_layer) {
541    offset += child->bounds().OffsetFromOrigin();
542    child->ReparentLayers(ancestor_with_layer->layer(), offset);
543  }
544
545  children_.push_back(child);
546  if (layout_manager_)
547    layout_manager_->OnWindowAddedToLayout(child);
548  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
549  child->OnParentChanged();
550
551  Window* root_window = GetRootWindow();
552  if (root_window && old_root != root_window) {
553    root_window->GetHost()->dispatcher()->OnWindowAddedToRootWindow(child);
554    child->NotifyAddedToRootWindow();
555  }
556
557  params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
558  NotifyWindowHierarchyChange(params);
559}
560
561void Window::RemoveChild(Window* child) {
562  WindowObserver::HierarchyChangeParams params;
563  params.target = child;
564  params.new_parent = NULL;
565  params.old_parent = this;
566  params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
567  NotifyWindowHierarchyChange(params);
568
569  RemoveChildImpl(child, NULL);
570
571  params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
572  NotifyWindowHierarchyChange(params);
573}
574
575bool Window::Contains(const Window* other) const {
576  for (const Window* parent = other; parent; parent = parent->parent_) {
577    if (parent == this)
578      return true;
579  }
580  return false;
581}
582
583Window* Window::GetChildById(int id) {
584  return const_cast<Window*>(const_cast<const Window*>(this)->GetChildById(id));
585}
586
587const Window* Window::GetChildById(int id) const {
588  Windows::const_iterator i;
589  for (i = children_.begin(); i != children_.end(); ++i) {
590    if ((*i)->id() == id)
591      return *i;
592    const Window* result = (*i)->GetChildById(id);
593    if (result)
594      return result;
595  }
596  return NULL;
597}
598
599// static
600void Window::ConvertPointToTarget(const Window* source,
601                                  const Window* target,
602                                  gfx::Point* point) {
603  if (!source)
604    return;
605  if (source->GetRootWindow() != target->GetRootWindow()) {
606    client::ScreenPositionClient* source_client =
607        client::GetScreenPositionClient(source->GetRootWindow());
608    // |source_client| can be NULL in tests.
609    if (source_client)
610      source_client->ConvertPointToScreen(source, point);
611
612    client::ScreenPositionClient* target_client =
613        client::GetScreenPositionClient(target->GetRootWindow());
614    // |target_client| can be NULL in tests.
615    if (target_client)
616      target_client->ConvertPointFromScreen(target, point);
617  } else if ((source != target) && (!source->layer() || !target->layer())) {
618    if (!source->layer()) {
619      gfx::Vector2d offset_to_layer;
620      source = source->GetAncestorWithLayer(&offset_to_layer);
621      *point += offset_to_layer;
622    }
623    if (!target->layer()) {
624      gfx::Vector2d offset_to_layer;
625      target = target->GetAncestorWithLayer(&offset_to_layer);
626      *point -= offset_to_layer;
627    }
628    ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
629  } else {
630    ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
631  }
632}
633
634// static
635void Window::ConvertRectToTarget(const Window* source,
636                                 const Window* target,
637                                 gfx::Rect* rect) {
638  DCHECK(rect);
639  gfx::Point origin = rect->origin();
640  ConvertPointToTarget(source, target, &origin);
641  rect->set_origin(origin);
642}
643
644void Window::MoveCursorTo(const gfx::Point& point_in_window) {
645  Window* root_window = GetRootWindow();
646  DCHECK(root_window);
647  gfx::Point point_in_root(point_in_window);
648  ConvertPointToTarget(this, root_window, &point_in_root);
649  root_window->GetHost()->MoveCursorTo(point_in_root);
650}
651
652gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
653  return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
654}
655
656void Window::AddObserver(WindowObserver* observer) {
657  observer->OnObservingWindow(this);
658  observers_.AddObserver(observer);
659}
660
661void Window::RemoveObserver(WindowObserver* observer) {
662  observer->OnUnobservingWindow(this);
663  observers_.RemoveObserver(observer);
664}
665
666bool Window::HasObserver(WindowObserver* observer) {
667  return observers_.HasObserver(observer);
668}
669
670bool Window::ContainsPointInRoot(const gfx::Point& point_in_root) const {
671  const Window* root_window = GetRootWindow();
672  if (!root_window)
673    return false;
674  gfx::Point local_point(point_in_root);
675  ConvertPointToTarget(root_window, this, &local_point);
676  return gfx::Rect(GetTargetBounds().size()).Contains(local_point);
677}
678
679bool Window::ContainsPoint(const gfx::Point& local_point) const {
680  return gfx::Rect(bounds().size()).Contains(local_point);
681}
682
683Window* Window::GetEventHandlerForPoint(const gfx::Point& local_point) {
684  return GetWindowForPoint(local_point, true, true);
685}
686
687Window* Window::GetTopWindowContainingPoint(const gfx::Point& local_point) {
688  return GetWindowForPoint(local_point, false, false);
689}
690
691Window* Window::GetToplevelWindow() {
692  Window* topmost_window_with_delegate = NULL;
693  for (aura::Window* window = this; window != NULL; window = window->parent()) {
694    if (window->delegate())
695      topmost_window_with_delegate = window;
696  }
697  return topmost_window_with_delegate;
698}
699
700void Window::Focus() {
701  client::FocusClient* client = client::GetFocusClient(this);
702  DCHECK(client);
703  client->FocusWindow(this);
704}
705
706void Window::Blur() {
707  client::FocusClient* client = client::GetFocusClient(this);
708  DCHECK(client);
709  client->FocusWindow(NULL);
710}
711
712bool Window::HasFocus() const {
713  client::FocusClient* client = client::GetFocusClient(this);
714  return client && client->GetFocusedWindow() == this;
715}
716
717bool Window::CanFocus() const {
718  if (IsRootWindow())
719    return IsVisible();
720
721  // NOTE: as part of focusing the window the ActivationClient may make the
722  // window visible (by way of making a hidden ancestor visible). For this
723  // reason we can't check visibility here and assume the client is doing it.
724  if (!parent_ || (delegate_ && !delegate_->CanFocus()))
725    return false;
726
727  // The client may forbid certain windows from receiving focus at a given point
728  // in time.
729  client::EventClient* client = client::GetEventClient(GetRootWindow());
730  if (client && !client->CanProcessEventsWithinSubtree(this))
731    return false;
732
733  return parent_->CanFocus();
734}
735
736bool Window::CanReceiveEvents() const {
737  if (IsRootWindow())
738    return IsVisible();
739
740  // The client may forbid certain windows from receiving events at a given
741  // point in time.
742  client::EventClient* client = client::GetEventClient(GetRootWindow());
743  if (client && !client->CanProcessEventsWithinSubtree(this))
744    return false;
745
746  return parent_ && IsVisible() && parent_->CanReceiveEvents();
747}
748
749void Window::SetCapture() {
750  if (!IsVisible())
751    return;
752
753  Window* root_window = GetRootWindow();
754  if (!root_window)
755    return;
756  client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
757  if (!capture_client)
758    return;
759  client::GetCaptureClient(root_window)->SetCapture(this);
760}
761
762void Window::ReleaseCapture() {
763  Window* root_window = GetRootWindow();
764  if (!root_window)
765    return;
766  client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
767  if (!capture_client)
768    return;
769  client::GetCaptureClient(root_window)->ReleaseCapture(this);
770}
771
772bool Window::HasCapture() {
773  Window* root_window = GetRootWindow();
774  if (!root_window)
775    return false;
776  client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
777  return capture_client && capture_client->GetCaptureWindow() == this;
778}
779
780void Window::SuppressPaint() {
781  if (layer())
782    layer()->SuppressPaint();
783}
784
785// {Set,Get,Clear}Property are implemented in window_property.h.
786
787void Window::SetNativeWindowProperty(const char* key, void* value) {
788  SetPropertyInternal(
789      key, key, NULL, reinterpret_cast<int64>(value), 0);
790}
791
792void* Window::GetNativeWindowProperty(const char* key) const {
793  return reinterpret_cast<void*>(GetPropertyInternal(key, 0));
794}
795
796void Window::OnDeviceScaleFactorChanged(float device_scale_factor) {
797  ScopedCursorHider hider(this);
798  if (delegate_)
799    delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
800}
801
802#if !defined(NDEBUG)
803std::string Window::GetDebugInfo() const {
804  return base::StringPrintf(
805      "%s<%d> bounds(%d, %d, %d, %d) %s %s opacity=%.1f",
806      name().empty() ? "Unknown" : name().c_str(), id(),
807      bounds().x(), bounds().y(), bounds().width(), bounds().height(),
808      visible_ ? "WindowVisible" : "WindowHidden",
809      layer() ?
810          (layer()->GetTargetVisibility() ? "LayerVisible" : "LayerHidden") :
811          "NoLayer",
812      layer() ? layer()->opacity() : 1.0f);
813}
814
815void Window::PrintWindowHierarchy(int depth) const {
816  VLOG(0) << base::StringPrintf(
817      "%*s%s", depth * 2, "", GetDebugInfo().c_str());
818  for (Windows::const_iterator it = children_.begin();
819       it != children_.end(); ++it) {
820    Window* child = *it;
821    child->PrintWindowHierarchy(depth + 1);
822  }
823}
824#endif
825
826void Window::RemoveOrDestroyChildren() {
827  while (!children_.empty()) {
828    Window* child = children_[0];
829    if (child->owned_by_parent_) {
830      delete child;
831      // Deleting the child so remove it from out children_ list.
832      DCHECK(std::find(children_.begin(), children_.end(), child) ==
833             children_.end());
834    } else {
835      // Even if we can't delete the child, we still need to remove it from the
836      // parent so that relevant bookkeeping (parent_ back-pointers etc) are
837      // updated.
838      RemoveChild(child);
839    }
840  }
841}
842
843///////////////////////////////////////////////////////////////////////////////
844// Window, private:
845
846int64 Window::SetPropertyInternal(const void* key,
847                                  const char* name,
848                                  PropertyDeallocator deallocator,
849                                  int64 value,
850                                  int64 default_value) {
851  int64 old = GetPropertyInternal(key, default_value);
852  if (value == default_value) {
853    prop_map_.erase(key);
854  } else {
855    Value prop_value;
856    prop_value.name = name;
857    prop_value.value = value;
858    prop_value.deallocator = deallocator;
859    prop_map_[key] = prop_value;
860  }
861  FOR_EACH_OBSERVER(WindowObserver, observers_,
862                    OnWindowPropertyChanged(this, key, old));
863  return old;
864}
865
866int64 Window::GetPropertyInternal(const void* key,
867                                  int64 default_value) const {
868  std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
869  if (iter == prop_map_.end())
870    return default_value;
871  return iter->second.value;
872}
873
874bool Window::HitTest(const gfx::Point& local_point) {
875  gfx::Rect local_bounds(bounds().size());
876  if (!delegate_ || !delegate_->HasHitTestMask())
877    return local_bounds.Contains(local_point);
878
879  gfx::Path mask;
880  delegate_->GetHitTestMask(&mask);
881
882  SkRegion clip_region;
883  clip_region.setRect(local_bounds.x(), local_bounds.y(),
884                      local_bounds.width(), local_bounds.height());
885  SkRegion mask_region;
886  return mask_region.setPath(mask, clip_region) &&
887      mask_region.contains(local_point.x(), local_point.y());
888}
889
890void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
891  gfx::Rect actual_new_bounds(new_bounds);
892  gfx::Rect old_bounds = GetTargetBounds();
893
894  // Always need to set the layer's bounds -- even if it is to the same thing.
895  // This may cause important side effects such as stopping animation.
896  if (!layer()) {
897    const gfx::Vector2d origin_delta = new_bounds.OffsetFromOrigin() -
898        bounds_.OffsetFromOrigin();
899    bounds_ = new_bounds;
900    OffsetLayerBounds(origin_delta);
901  } else {
902    if (parent_ && !parent_->layer()) {
903      gfx::Vector2d offset;
904      const aura::Window* ancestor_with_layer =
905          parent_->GetAncestorWithLayer(&offset);
906      if (ancestor_with_layer)
907        actual_new_bounds.Offset(offset);
908    }
909    layer()->SetBounds(actual_new_bounds);
910  }
911
912  // If we are currently not the layer's delegate, we will not get bounds
913  // changed notification from the layer (this typically happens after animating
914  // hidden). We must notify ourselves.
915  if (!layer() || layer()->delegate() != this)
916    OnWindowBoundsChanged(old_bounds);
917}
918
919void Window::SetVisible(bool visible) {
920  if ((layer() && visible == layer()->GetTargetVisibility()) ||
921      (!layer() && visible == visible_))
922    return;  // No change.
923
924  FOR_EACH_OBSERVER(WindowObserver, observers_,
925                    OnWindowVisibilityChanging(this, visible));
926
927  client::VisibilityClient* visibility_client =
928      client::GetVisibilityClient(this);
929  if (visibility_client)
930    visibility_client->UpdateLayerVisibility(this, visible);
931  else if (layer())
932    layer()->SetVisible(visible);
933  visible_ = visible;
934  SchedulePaint();
935  if (parent_ && parent_->layout_manager_)
936    parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
937
938  if (delegate_)
939    delegate_->OnWindowTargetVisibilityChanged(visible);
940
941  NotifyWindowVisibilityChanged(this, visible);
942}
943
944void Window::SchedulePaint() {
945  SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
946}
947
948void Window::Paint(gfx::Canvas* canvas) {
949  if (delegate_)
950    delegate_->OnPaint(canvas);
951  PaintLayerlessChildren(canvas);
952}
953
954void Window::PaintLayerlessChildren(gfx::Canvas* canvas) {
955  for (size_t i = 0, count = children_.size(); i < count; ++i) {
956    Window* child = children_[i];
957    if (!child->layer() && child->visible_) {
958      gfx::ScopedCanvas scoped_canvas(canvas);
959      canvas->ClipRect(child->bounds());
960      if (!canvas->IsClipEmpty()) {
961        canvas->Translate(child->bounds().OffsetFromOrigin());
962        child->Paint(canvas);
963      }
964    }
965  }
966}
967
968Window* Window::GetWindowForPoint(const gfx::Point& local_point,
969                                  bool return_tightest,
970                                  bool for_event_handling) {
971  if (!IsVisible())
972    return NULL;
973
974  if ((for_event_handling && !HitTest(local_point)) ||
975      (!for_event_handling && !ContainsPoint(local_point)))
976    return NULL;
977
978  // Check if I should claim this event and not pass it to my children because
979  // the location is inside my hit test override area.  For details, see
980  // set_hit_test_bounds_override_inner().
981  if (for_event_handling && !hit_test_bounds_override_inner_.empty()) {
982    gfx::Rect inset_local_bounds(gfx::Point(), bounds().size());
983    inset_local_bounds.Inset(hit_test_bounds_override_inner_);
984    // We know we're inside the normal local bounds, so if we're outside the
985    // inset bounds we must be in the special hit test override area.
986    DCHECK(HitTest(local_point));
987    if (!inset_local_bounds.Contains(local_point))
988      return delegate_ ? this : NULL;
989  }
990
991  if (!return_tightest && delegate_)
992    return this;
993
994  for (Windows::const_reverse_iterator it = children_.rbegin(),
995           rend = children_.rend();
996       it != rend; ++it) {
997    Window* child = *it;
998
999    if (for_event_handling) {
1000      if (child->ignore_events_)
1001        continue;
1002      // The client may not allow events to be processed by certain subtrees.
1003      client::EventClient* client = client::GetEventClient(GetRootWindow());
1004      if (client && !client->CanProcessEventsWithinSubtree(child))
1005        continue;
1006      if (delegate_ && !delegate_->ShouldDescendIntoChildForEventHandling(
1007              child, local_point))
1008        continue;
1009    }
1010
1011    gfx::Point point_in_child_coords(local_point);
1012    ConvertPointToTarget(this, child, &point_in_child_coords);
1013    Window* match = child->GetWindowForPoint(point_in_child_coords,
1014                                             return_tightest,
1015                                             for_event_handling);
1016    if (match)
1017      return match;
1018  }
1019
1020  return delegate_ ? this : NULL;
1021}
1022
1023void Window::RemoveChildImpl(Window* child, Window* new_parent) {
1024  if (layout_manager_)
1025    layout_manager_->OnWillRemoveWindowFromLayout(child);
1026  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
1027  Window* root_window = child->GetRootWindow();
1028  Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
1029  if (root_window && root_window != new_root_window)
1030    child->NotifyRemovingFromRootWindow(new_root_window);
1031
1032  gfx::Vector2d offset;
1033  GetAncestorWithLayer(&offset);
1034  child->UnparentLayers(!layer(), offset);
1035  child->parent_ = NULL;
1036  Windows::iterator i = std::find(children_.begin(), children_.end(), child);
1037  DCHECK(i != children_.end());
1038  children_.erase(i);
1039  child->OnParentChanged();
1040  if (layout_manager_)
1041    layout_manager_->OnWindowRemovedFromLayout(child);
1042}
1043
1044void Window::UnparentLayers(bool has_layerless_ancestor,
1045                            const gfx::Vector2d& offset) {
1046  if (!layer()) {
1047    const gfx::Vector2d new_offset = offset + bounds().OffsetFromOrigin();
1048    for (size_t i = 0; i < children_.size(); ++i) {
1049      children_[i]->UnparentLayers(true, new_offset);
1050    }
1051  } else {
1052    // Only remove the layer if we still own it.  Someone else may have acquired
1053    // ownership of it via AcquireLayer() and may expect the hierarchy to go
1054    // unchanged as the Window is destroyed.
1055    if (OwnsLayer()) {
1056      if (layer()->parent())
1057        layer()->parent()->Remove(layer());
1058      if (has_layerless_ancestor) {
1059        const gfx::Rect real_bounds(bounds_);
1060        gfx::Rect layer_bounds(layer()->bounds());
1061        layer_bounds.Offset(-offset);
1062        layer()->SetBounds(layer_bounds);
1063        bounds_ = real_bounds;
1064      }
1065    }
1066  }
1067}
1068
1069void Window::ReparentLayers(ui::Layer* parent_layer,
1070                            const gfx::Vector2d& offset) {
1071  if (!layer()) {
1072    for (size_t i = 0; i < children_.size(); ++i) {
1073      children_[i]->ReparentLayers(
1074          parent_layer,
1075          offset + children_[i]->bounds().OffsetFromOrigin());
1076    }
1077  } else {
1078    const gfx::Rect real_bounds(bounds());
1079    parent_layer->Add(layer());
1080    gfx::Rect layer_bounds(layer()->bounds().size());
1081    layer_bounds += offset;
1082    layer()->SetBounds(layer_bounds);
1083    bounds_ = real_bounds;
1084  }
1085}
1086
1087void Window::OffsetLayerBounds(const gfx::Vector2d& offset) {
1088  if (!layer()) {
1089    for (size_t i = 0; i < children_.size(); ++i)
1090      children_[i]->OffsetLayerBounds(offset);
1091  } else {
1092    gfx::Rect layer_bounds(layer()->bounds());
1093    layer_bounds += offset;
1094    layer()->SetBounds(layer_bounds);
1095  }
1096}
1097
1098void Window::OnParentChanged() {
1099  FOR_EACH_OBSERVER(
1100      WindowObserver, observers_, OnWindowParentChanged(this, parent_));
1101}
1102
1103void Window::StackChildRelativeTo(Window* child,
1104                                  Window* target,
1105                                  StackDirection direction) {
1106  DCHECK_NE(child, target);
1107  DCHECK(child);
1108  DCHECK(target);
1109  DCHECK_EQ(this, child->parent());
1110  DCHECK_EQ(this, target->parent());
1111
1112  client::WindowStackingClient* stacking_client =
1113      client::GetWindowStackingClient();
1114  if (stacking_client &&
1115      !stacking_client->AdjustStacking(&child, &target, &direction))
1116    return;
1117
1118  const size_t child_i =
1119      std::find(children_.begin(), children_.end(), child) - children_.begin();
1120  const size_t target_i =
1121      std::find(children_.begin(), children_.end(), target) - children_.begin();
1122
1123  // Don't move the child if it is already in the right place.
1124  if ((direction == STACK_ABOVE && child_i == target_i + 1) ||
1125      (direction == STACK_BELOW && child_i + 1 == target_i))
1126    return;
1127
1128  const size_t dest_i =
1129      direction == STACK_ABOVE ?
1130      (child_i < target_i ? target_i : target_i + 1) :
1131      (child_i < target_i ? target_i - 1 : target_i);
1132  children_.erase(children_.begin() + child_i);
1133  children_.insert(children_.begin() + dest_i, child);
1134
1135  StackChildLayerRelativeTo(child, target, direction);
1136
1137  child->OnStackingChanged();
1138}
1139
1140void Window::StackChildLayerRelativeTo(Window* child,
1141                                       Window* target,
1142                                       StackDirection direction) {
1143  Window* ancestor_with_layer = GetAncestorWithLayer(NULL);
1144  ui::Layer* ancestor_layer =
1145      ancestor_with_layer ? ancestor_with_layer->layer() : NULL;
1146  if (!ancestor_layer)
1147    return;
1148
1149  if (child->layer() && target->layer()) {
1150    if (direction == STACK_ABOVE)
1151      ancestor_layer->StackAbove(child->layer(), target->layer());
1152    else
1153      ancestor_layer->StackBelow(child->layer(), target->layer());
1154    return;
1155  }
1156  typedef std::vector<ui::Layer*> Layers;
1157  Layers layers;
1158  GetLayersToStack(child, &layers);
1159  if (layers.empty())
1160    return;
1161
1162  ui::Layer* target_layer;
1163  if (direction == STACK_ABOVE) {
1164    target_layer =
1165        FindStackingTargetLayer<Windows::const_reverse_iterator>(target, child);
1166  } else {
1167    target_layer =
1168        FindStackingTargetLayer<Windows::const_iterator>(target, child);
1169  }
1170
1171  if (!target_layer) {
1172    if (direction == STACK_ABOVE) {
1173      for (Layers::const_reverse_iterator i = layers.rbegin(),
1174               rend = layers.rend(); i != rend; ++i) {
1175        ancestor_layer->StackAtBottom(*i);
1176      }
1177    } else {
1178      for (Layers::const_iterator i = layers.begin(); i != layers.end(); ++i)
1179        ancestor_layer->StackAtTop(*i);
1180    }
1181    return;
1182  }
1183
1184  if (direction == STACK_ABOVE) {
1185    for (Layers::const_reverse_iterator i = layers.rbegin(),
1186             rend = layers.rend(); i != rend; ++i) {
1187      ancestor_layer->StackAbove(*i, target_layer);
1188    }
1189  } else {
1190    for (Layers::const_iterator i = layers.begin(); i != layers.end(); ++i)
1191      ancestor_layer->StackBelow(*i, target_layer);
1192  }
1193}
1194
1195void Window::OnStackingChanged() {
1196  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowStackingChanged(this));
1197}
1198
1199void Window::NotifyRemovingFromRootWindow(Window* new_root) {
1200  FOR_EACH_OBSERVER(WindowObserver, observers_,
1201                    OnWindowRemovingFromRootWindow(this, new_root));
1202  for (Window::Windows::const_iterator it = children_.begin();
1203       it != children_.end(); ++it) {
1204    (*it)->NotifyRemovingFromRootWindow(new_root);
1205  }
1206}
1207
1208void Window::NotifyAddedToRootWindow() {
1209  FOR_EACH_OBSERVER(WindowObserver, observers_,
1210                    OnWindowAddedToRootWindow(this));
1211  for (Window::Windows::const_iterator it = children_.begin();
1212       it != children_.end(); ++it) {
1213    (*it)->NotifyAddedToRootWindow();
1214  }
1215}
1216
1217void Window::NotifyWindowHierarchyChange(
1218    const WindowObserver::HierarchyChangeParams& params) {
1219  params.target->NotifyWindowHierarchyChangeDown(params);
1220  switch (params.phase) {
1221  case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING:
1222    if (params.old_parent)
1223      params.old_parent->NotifyWindowHierarchyChangeUp(params);
1224    break;
1225  case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED:
1226    if (params.new_parent)
1227      params.new_parent->NotifyWindowHierarchyChangeUp(params);
1228    break;
1229  default:
1230    NOTREACHED();
1231    break;
1232  }
1233}
1234
1235void Window::NotifyWindowHierarchyChangeDown(
1236    const WindowObserver::HierarchyChangeParams& params) {
1237  NotifyWindowHierarchyChangeAtReceiver(params);
1238  for (Window::Windows::const_iterator it = children_.begin();
1239       it != children_.end(); ++it) {
1240    (*it)->NotifyWindowHierarchyChangeDown(params);
1241  }
1242}
1243
1244void Window::NotifyWindowHierarchyChangeUp(
1245    const WindowObserver::HierarchyChangeParams& params) {
1246  for (Window* window = this; window; window = window->parent())
1247    window->NotifyWindowHierarchyChangeAtReceiver(params);
1248}
1249
1250void Window::NotifyWindowHierarchyChangeAtReceiver(
1251    const WindowObserver::HierarchyChangeParams& params) {
1252  WindowObserver::HierarchyChangeParams local_params = params;
1253  local_params.receiver = this;
1254
1255  switch (params.phase) {
1256  case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING:
1257    FOR_EACH_OBSERVER(WindowObserver, observers_,
1258                      OnWindowHierarchyChanging(local_params));
1259    break;
1260  case WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED:
1261    FOR_EACH_OBSERVER(WindowObserver, observers_,
1262                      OnWindowHierarchyChanged(local_params));
1263    break;
1264  default:
1265    NOTREACHED();
1266    break;
1267  }
1268}
1269
1270void Window::NotifyWindowVisibilityChanged(aura::Window* target,
1271                                           bool visible) {
1272  if (!NotifyWindowVisibilityChangedDown(target, visible)) {
1273    return; // |this| has been deleted.
1274  }
1275  NotifyWindowVisibilityChangedUp(target, visible);
1276}
1277
1278bool Window::NotifyWindowVisibilityChangedAtReceiver(aura::Window* target,
1279                                                     bool visible) {
1280  // |this| may be deleted during a call to OnWindowVisibilityChanged() on one
1281  // of the observers. We create an local observer for that. In that case we
1282  // exit without further access to any members.
1283  WindowTracker tracker;
1284  tracker.Add(this);
1285  FOR_EACH_OBSERVER(WindowObserver, observers_,
1286                    OnWindowVisibilityChanged(target, visible));
1287  return tracker.Contains(this);
1288}
1289
1290bool Window::NotifyWindowVisibilityChangedDown(aura::Window* target,
1291                                               bool visible) {
1292  if (!NotifyWindowVisibilityChangedAtReceiver(target, visible))
1293    return false; // |this| was deleted.
1294  std::set<const Window*> child_already_processed;
1295  bool child_destroyed = false;
1296  do {
1297    child_destroyed = false;
1298    for (Window::Windows::const_iterator it = children_.begin();
1299         it != children_.end(); ++it) {
1300      if (!child_already_processed.insert(*it).second)
1301        continue;
1302      if (!(*it)->NotifyWindowVisibilityChangedDown(target, visible)) {
1303        // |*it| was deleted, |it| is invalid and |children_| has changed.
1304        // We exit the current for-loop and enter a new one.
1305        child_destroyed = true;
1306        break;
1307      }
1308    }
1309  } while (child_destroyed);
1310  return true;
1311}
1312
1313void Window::NotifyWindowVisibilityChangedUp(aura::Window* target,
1314                                             bool visible) {
1315  for (Window* window = this; window; window = window->parent()) {
1316    bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
1317    DCHECK(ret);
1318  }
1319}
1320
1321void Window::NotifyAncestorWindowTransformed(Window* source) {
1322  FOR_EACH_OBSERVER(WindowObserver, observers_,
1323                    OnAncestorWindowTransformed(source, this));
1324  for (Window::Windows::const_iterator it = children_.begin();
1325       it != children_.end(); ++it) {
1326    (*it)->NotifyAncestorWindowTransformed(source);
1327  }
1328}
1329
1330void Window::OnWindowBoundsChanged(const gfx::Rect& old_bounds) {
1331  if (layer()) {
1332    bounds_ = layer()->bounds();
1333    if (parent_ && !parent_->layer()) {
1334      gfx::Vector2d offset;
1335      aura::Window* ancestor_with_layer =
1336          parent_->GetAncestorWithLayer(&offset);
1337      if (ancestor_with_layer)
1338        bounds_.Offset(-offset);
1339    }
1340  }
1341
1342  if (layout_manager_)
1343    layout_manager_->OnWindowResized();
1344  if (delegate_)
1345    delegate_->OnBoundsChanged(old_bounds, bounds());
1346  FOR_EACH_OBSERVER(WindowObserver,
1347                    observers_,
1348                    OnWindowBoundsChanged(this, old_bounds, bounds()));
1349}
1350
1351bool Window::CleanupGestureState() {
1352  bool state_modified = false;
1353  state_modified |= ui::GestureRecognizer::Get()->CancelActiveTouches(this);
1354  state_modified |=
1355      ui::GestureRecognizer::Get()->CleanupStateForConsumer(this);
1356  for (Window::Windows::iterator iter = children_.begin();
1357       iter != children_.end();
1358       ++iter) {
1359    state_modified |= (*iter)->CleanupGestureState();
1360  }
1361  return state_modified;
1362}
1363
1364void Window::OnPaintLayer(gfx::Canvas* canvas) {
1365  Paint(canvas);
1366}
1367
1368void Window::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
1369  DCHECK(layer());
1370  FOR_EACH_OBSERVER(WindowObserver,
1371                    observers_,
1372                    OnDelegatedFrameDamage(this, damage_rect_in_dip));
1373}
1374
1375base::Closure Window::PrepareForLayerBoundsChange() {
1376  return base::Bind(&Window::OnWindowBoundsChanged, base::Unretained(this),
1377                    bounds());
1378}
1379
1380bool Window::CanAcceptEvent(const ui::Event& event) {
1381  // The client may forbid certain windows from receiving events at a given
1382  // point in time.
1383  client::EventClient* client = client::GetEventClient(GetRootWindow());
1384  if (client && !client->CanProcessEventsWithinSubtree(this))
1385    return false;
1386
1387  // We need to make sure that a touch cancel event and any gesture events it
1388  // creates can always reach the window. This ensures that we receive a valid
1389  // touch / gesture stream.
1390  if (event.IsEndingEvent())
1391    return true;
1392
1393  if (!IsVisible())
1394    return false;
1395
1396  // The top-most window can always process an event.
1397  if (!parent_)
1398    return true;
1399
1400  // For located events (i.e. mouse, touch etc.), an assumption is made that
1401  // windows that don't have a default event-handler cannot process the event
1402  // (see more in GetWindowForPoint()). This assumption is not made for key
1403  // events.
1404  return event.IsKeyEvent() || target_handler();
1405}
1406
1407ui::EventTarget* Window::GetParentTarget() {
1408  if (IsRootWindow()) {
1409    return client::GetEventClient(this) ?
1410        client::GetEventClient(this)->GetToplevelEventTarget() :
1411            Env::GetInstance();
1412  }
1413  return parent_;
1414}
1415
1416scoped_ptr<ui::EventTargetIterator> Window::GetChildIterator() const {
1417  return scoped_ptr<ui::EventTargetIterator>(
1418      new ui::EventTargetIteratorImpl<Window>(children()));
1419}
1420
1421ui::EventTargeter* Window::GetEventTargeter() {
1422  return targeter_.get();
1423}
1424
1425void Window::ConvertEventToTarget(ui::EventTarget* target,
1426                                  ui::LocatedEvent* event) {
1427  event->ConvertLocationToTarget(this,
1428                                 static_cast<Window*>(target));
1429}
1430
1431void Window::UpdateLayerName() {
1432#if !defined(NDEBUG)
1433  DCHECK(layer());
1434
1435  std::string layer_name(name_);
1436  if (layer_name.empty())
1437    layer_name = "Unnamed Window";
1438
1439  if (id_ != -1)
1440    layer_name += " " + base::IntToString(id_);
1441
1442  layer()->set_name(layer_name);
1443#endif
1444}
1445
1446bool Window::ContainsMouse() {
1447  bool contains_mouse = false;
1448  if (IsVisible()) {
1449    WindowTreeHost* host = GetHost();
1450    contains_mouse = host &&
1451        ContainsPointInRoot(host->dispatcher()->GetLastMouseLocationInRoot());
1452  }
1453  return contains_mouse;
1454}
1455
1456const Window* Window::GetAncestorWithLayer(gfx::Vector2d* offset) const {
1457  for (const aura::Window* window = this; window; window = window->parent()) {
1458    if (window->layer())
1459      return window;
1460    if (offset)
1461      *offset += window->bounds().OffsetFromOrigin();
1462  }
1463  if (offset)
1464    *offset = gfx::Vector2d();
1465  return NULL;
1466}
1467
1468}  // namespace aura
1469