ui/views/view.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 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
   6
   7 #include "ui/views/view.h"
   8
   9 #include <algorithm>
  10 #include <cmath>
  11
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/trace_event/trace_event.h"
  18 #include "third_party/skia/include/core/SkRect.h"
  19 #include "ui/accessibility/ax_enums.h"
  20 #include "ui/base/cursor/cursor.h"
  21 #include "ui/base/dragdrop/drag_drop_types.h"
  22 #include "ui/base/ime/input_method.h"
  23 #include "ui/compositor/clip_transform_recorder.h"
  24 #include "ui/compositor/compositor.h"
  25 #include "ui/compositor/dip_util.h"
  26 #include "ui/compositor/layer.h"
  27 #include "ui/compositor/layer_animator.h"
  28 #include "ui/compositor/paint_context.h"
  29 #include "ui/compositor/paint_recorder.h"
  30 #include "ui/events/event_target_iterator.h"
  31 #include "ui/gfx/canvas.h"
  32 #include "ui/gfx/geometry/point3_f.h"
  33 #include "ui/gfx/geometry/point_conversions.h"
  34 #include "ui/gfx/interpolated_transform.h"
  35 #include "ui/gfx/path.h"
  36 #include "ui/gfx/scoped_canvas.h"
  37 #include "ui/gfx/screen.h"
  38 #include "ui/gfx/skia_util.h"
  39 #include "ui/gfx/transform.h"
  40 #include "ui/native_theme/native_theme.h"
  41 #include "ui/views/accessibility/native_view_accessibility.h"
  42 #include "ui/views/background.h"
  43 #include "ui/views/border.h"
  44 #include "ui/views/context_menu_controller.h"
  45 #include "ui/views/drag_controller.h"
  46 #include "ui/views/focus/view_storage.h"
  47 #include "ui/views/layout/layout_manager.h"
  48 #include "ui/views/views_delegate.h"
  49 #include "ui/views/widget/native_widget_private.h"
  50 #include "ui/views/widget/root_view.h"
  51 #include "ui/views/widget/tooltip_manager.h"
  52 #include "ui/views/widget/widget.h"
  53
  54 #if defined(OS_WIN)
  55 #include "base/win/scoped_gdi_object.h"
  56 #endif
  57
  58 namespace views {
  59
  60 namespace {
  61
  62 #if defined(OS_WIN)
  63 const bool kContextMenuOnMousePress = false;
  64 #else
  65 const bool kContextMenuOnMousePress = true;
  66 #endif
  67
  68 // Default horizontal drag threshold in pixels.
  69 // Same as what gtk uses.
  70 const int kDefaultHorizontalDragThreshold = 8;
  71
  72 // Default vertical drag threshold in pixels.
  73 // Same as what gtk uses.
  74 const int kDefaultVerticalDragThreshold = 8;
  75
  76 // Returns the top view in |view|'s hierarchy.
  77 const View* GetHierarchyRoot(const View* view) {
  78   const View* root = view;
  79   while (root && root->parent())
  80     root = root->parent();
  81   return root;
  82 }
  83
  84 }  // namespace
  85
  86 // static
  87 const char View::kViewClassName[] = "View";
  88
  89 ////////////////////////////////////////////////////////////////////////////////
  90 // View, public:
  91
  92 // Creation and lifetime -------------------------------------------------------
  93
  94 View::View()
  95     : owned_by_client_(false),
  96       id_(0),
  97       group_(-1),
  98       parent_(NULL),
  99       visible_(true),
 100       enabled_(true),
 101       notify_enter_exit_on_child_(false),
 102       registered_for_visible_bounds_notification_(false),
 103       clip_insets_(0, 0, 0, 0),
 104       needs_layout_(true),
 105       snap_layer_to_pixel_boundary_(false),
 106       flip_canvas_on_paint_for_rtl_ui_(false),
 107       paint_to_layer_(false),
 108       accelerator_focus_manager_(NULL),
 109       registered_accelerator_count_(0),
 110       next_focusable_view_(NULL),
 111       previous_focusable_view_(NULL),
 112       focusable_(false),
 113       accessibility_focusable_(false),
 114       context_menu_controller_(NULL),
 115       drag_controller_(NULL),
 116       native_view_accessibility_(NULL) {
 117 }
 118
 119 View::~View() {
 120   if (parent_)
 121     parent_->RemoveChildView(this);
 122
 123   ViewStorage::GetInstance()->ViewRemoved(this);
 124
 125   for (Views::const_iterator i(children_.begin()); i != children_.end(); ++i) {
 126     (*i)->parent_ = NULL;
 127     if (!(*i)->owned_by_client_)
 128       delete *i;
 129   }
 130
 131   // Release ownership of the native accessibility object, but it's
 132   // reference-counted on some platforms, so it may not be deleted right away.
 133   if (native_view_accessibility_)
 134     native_view_accessibility_->Destroy();
 135 }
 136
 137 // Tree operations -------------------------------------------------------------
 138
 139 const Widget* View::GetWidget() const {
 140   // The root view holds a reference to this view hierarchy's Widget.
 141   return parent_ ? parent_->GetWidget() : NULL;
 142 }
 143
 144 Widget* View::GetWidget() {
 145   return const_cast<Widget*>(const_cast<const View*>(this)->GetWidget());
 146 }
 147
 148 void View::AddChildView(View* view) {
 149   if (view->parent_ == this)
 150     return;
 151   AddChildViewAt(view, child_count());
 152 }
 153
 154 void View::AddChildViewAt(View* view, int index) {
 155   CHECK_NE(view, this) << "You cannot add a view as its own child";
 156   DCHECK_GE(index, 0);
 157   DCHECK_LE(index, child_count());
 158
 159   // If |view| has a parent, remove it from its parent.
 160   View* parent = view->parent_;
 161   ui::NativeTheme* old_theme = NULL;
 162   if (parent) {
 163     old_theme = view->GetNativeTheme();
 164     if (parent == this) {
 165       ReorderChildView(view, index);
 166       return;
 167     }
 168     parent->DoRemoveChildView(view, true, true, false, this);
 169   }
 170
 171   // Sets the prev/next focus views.
 172   InitFocusSiblings(view, index);
 173
 174   // Let's insert the view.
 175   view->parent_ = this;
 176   children_.insert(children_.begin() + index, view);
 177
 178   views::Widget* widget = GetWidget();
 179   if (widget) {
 180     const ui::NativeTheme* new_theme = view->GetNativeTheme();
 181     if (new_theme != old_theme)
 182       view->PropagateNativeThemeChanged(new_theme);
 183   }
 184
 185   ViewHierarchyChangedDetails details(true, this, view, parent);
 186
 187   for (View* v = this; v; v = v->parent_)
 188     v->ViewHierarchyChangedImpl(false, details);
 189
 190   view->PropagateAddNotifications(details);
 191   UpdateTooltip();
 192   if (widget) {
 193     RegisterChildrenForVisibleBoundsNotification(view);
 194     if (view->visible())
 195       view->SchedulePaint();
 196   }
 197
 198   if (layout_manager_.get())
 199     layout_manager_->ViewAdded(this, view);
 200
 201   ReorderLayers();
 202
 203   // Make sure the visibility of the child layers are correct.
 204   // If any of the parent View is hidden, then the layers of the subtree
 205   // rooted at |this| should be hidden. Otherwise, all the child layers should
 206   // inherit the visibility of the owner View.
 207   UpdateLayerVisibility();
 208 }
 209
 210 void View::ReorderChildView(View* view, int index) {
 211   DCHECK_EQ(view->parent_, this);
 212   if (index < 0)
 213     index = child_count() - 1;
 214   else if (index >= child_count())
 215     return;
 216   if (children_[index] == view)
 217     return;
 218
 219   const Views::iterator i(std::find(children_.begin(), children_.end(), view));
 220   DCHECK(i != children_.end());
 221   children_.erase(i);
 222
 223   // Unlink the view first
 224   View* next_focusable = view->next_focusable_view_;
 225   View* prev_focusable = view->previous_focusable_view_;
 226   if (prev_focusable)
 227     prev_focusable->next_focusable_view_ = next_focusable;
 228   if (next_focusable)
 229     next_focusable->previous_focusable_view_ = prev_focusable;
 230
 231   // Add it in the specified index now.
 232   InitFocusSiblings(view, index);
 233   children_.insert(children_.begin() + index, view);
 234
 235   ReorderLayers();
 236 }
 237
 238 void View::RemoveChildView(View* view) {
 239   DoRemoveChildView(view, true, true, false, NULL);
 240 }
 241
 242 void View::RemoveAllChildViews(bool delete_children) {
 243   while (!children_.empty())
 244     DoRemoveChildView(children_.front(), false, false, delete_children, NULL);
 245   UpdateTooltip();
 246 }
 247
 248 bool View::Contains(const View* view) const {
 249   for (const View* v = view; v; v = v->parent_) {
 250     if (v == this)
 251       return true;
 252   }
 253   return false;
 254 }
 255
 256 int View::GetIndexOf(const View* view) const {
 257   Views::const_iterator i(std::find(children_.begin(), children_.end(), view));
 258   return i != children_.end() ? static_cast<int>(i - children_.begin()) : -1;
 259 }
 260
 261 // Size and disposition --------------------------------------------------------
 262
 263 void View::SetBounds(int x, int y, int width, int height) {
 264   SetBoundsRect(gfx::Rect(x, y, std::max(0, width), std::max(0, height)));
 265 }
 266
 267 void View::SetBoundsRect(const gfx::Rect& bounds) {
 268   if (bounds == bounds_) {
 269     if (needs_layout_) {
 270       needs_layout_ = false;
 271       Layout();
 272     }
 273     return;
 274   }
 275
 276   if (visible_) {
 277     // Paint where the view is currently.
 278     SchedulePaintBoundsChanged(
 279         bounds_.size() == bounds.size() ? SCHEDULE_PAINT_SIZE_SAME :
 280         SCHEDULE_PAINT_SIZE_CHANGED);
 281   }
 282
 283   gfx::Rect prev = bounds_;
 284   bounds_ = bounds;
 285   BoundsChanged(prev);
 286 }
 287
 288 void View::SetSize(const gfx::Size& size) {
 289   SetBounds(x(), y(), size.width(), size.height());
 290 }
 291
 292 void View::SetPosition(const gfx::Point& position) {
 293   SetBounds(position.x(), position.y(), width(), height());
 294 }
 295
 296 void View::SetX(int x) {
 297   SetBounds(x, y(), width(), height());
 298 }
 299
 300 void View::SetY(int y) {
 301   SetBounds(x(), y, width(), height());
 302 }
 303
 304 gfx::Rect View::GetContentsBounds() const {
 305   gfx::Rect contents_bounds(GetLocalBounds());
 306   if (border_.get())
 307     contents_bounds.Inset(border_->GetInsets());
 308   return contents_bounds;
 309 }
 310
 311 gfx::Rect View::GetLocalBounds() const {
 312   return gfx::Rect(size());
 313 }
 314
 315 gfx::Rect View::GetLayerBoundsInPixel() const {
 316   return layer()->GetTargetBounds();
 317 }
 318
 319 gfx::Insets View::GetInsets() const {
 320   return border_.get() ? border_->GetInsets() : gfx::Insets();
 321 }
 322
 323 gfx::Rect View::GetVisibleBounds() const {
 324   if (!IsDrawn())
 325     return gfx::Rect();
 326   gfx::Rect vis_bounds(GetLocalBounds());
 327   gfx::Rect ancestor_bounds;
 328   const View* view = this;
 329   gfx::Transform transform;
 330
 331   while (view != NULL && !vis_bounds.IsEmpty()) {
 332     transform.ConcatTransform(view->GetTransform());
 333     gfx::Transform translation;
 334     translation.Translate(static_cast<float>(view->GetMirroredX()),
 335                           static_cast<float>(view->y()));
 336     transform.ConcatTransform(translation);
 337
 338     vis_bounds = view->ConvertRectToParent(vis_bounds);
 339     const View* ancestor = view->parent_;
 340     if (ancestor != NULL) {
 341       ancestor_bounds.SetRect(0, 0, ancestor->width(), ancestor->height());
 342       vis_bounds.Intersect(ancestor_bounds);
 343     } else if (!view->GetWidget()) {
 344       // If the view has no Widget, we're not visible. Return an empty rect.
 345       return gfx::Rect();
 346     }
 347     view = ancestor;
 348   }
 349   if (vis_bounds.IsEmpty())
 350     return vis_bounds;
 351   // Convert back to this views coordinate system.
 352   gfx::RectF views_vis_bounds(vis_bounds);
 353   transform.TransformRectReverse(&views_vis_bounds);
 354   // Partially visible pixels should be considered visible.
 355   return gfx::ToEnclosingRect(views_vis_bounds);
 356 }
 357
 358 gfx::Rect View::GetBoundsInScreen() const {
 359   gfx::Point origin;
 360   View::ConvertPointToScreen(this, &origin);
 361   return gfx::Rect(origin, size());
 362 }
 363
 364 gfx::Size View::GetPreferredSize() const {
 365   if (layout_manager_.get())
 366     return layout_manager_->GetPreferredSize(this);
 367   return gfx::Size();
 368 }
 369
 370 int View::GetBaseline() const {
 371   return -1;
 372 }
 373
 374 void View::SizeToPreferredSize() {
 375   gfx::Size prefsize = GetPreferredSize();
 376   if ((prefsize.width() != width()) || (prefsize.height() != height()))
 377     SetBounds(x(), y(), prefsize.width(), prefsize.height());
 378 }
 379
 380 gfx::Size View::GetMinimumSize() const {
 381   return GetPreferredSize();
 382 }
 383
 384 gfx::Size View::GetMaximumSize() const {
 385   return gfx::Size();
 386 }
 387
 388 int View::GetHeightForWidth(int w) const {
 389   if (layout_manager_.get())
 390     return layout_manager_->GetPreferredHeightForWidth(this, w);
 391   return GetPreferredSize().height();
 392 }
 393
 394 void View::SetVisible(bool visible) {
 395   if (visible != visible_) {
 396     // If the View is currently visible, schedule paint to refresh parent.
 397     // TODO(beng): not sure we should be doing this if we have a layer.
 398     if (visible_)
 399       SchedulePaint();
 400
 401     visible_ = visible;
 402     AdvanceFocusIfNecessary();
 403
 404     // Notify the parent.
 405     if (parent_)
 406       parent_->ChildVisibilityChanged(this);
 407
 408     // This notifies all sub-views recursively.
 409     PropagateVisibilityNotifications(this, visible_);
 410     UpdateLayerVisibility();
 411
 412     // If we are newly visible, schedule paint.
 413     if (visible_)
 414       SchedulePaint();
 415   }
 416 }
 417
 418 bool View::IsDrawn() const {
 419   return visible_ && parent_ ? parent_->IsDrawn() : false;
 420 }
 421
 422 void View::SetEnabled(bool enabled) {
 423   if (enabled != enabled_) {
 424     enabled_ = enabled;
 425     AdvanceFocusIfNecessary();
 426     OnEnabledChanged();
 427   }
 428 }
 429
 430 void View::OnEnabledChanged() {
 431   SchedulePaint();
 432 }
 433
 434 // Transformations -------------------------------------------------------------
 435
 436 gfx::Transform View::GetTransform() const {
 437   return layer() ? layer()->transform() : gfx::Transform();
 438 }
 439
 440 void View::SetTransform(const gfx::Transform& transform) {
 441   if (transform.IsIdentity()) {
 442     if (layer()) {
 443       layer()->SetTransform(transform);
 444       if (!paint_to_layer_)
 445         DestroyLayer();
 446     } else {
 447       // Nothing.
 448     }
 449   } else {
 450     if (!layer())
 451       CreateLayer();
 452     layer()->SetTransform(transform);
 453     layer()->ScheduleDraw();
 454   }
 455 }
 456
 457 void View::SetPaintToLayer(bool paint_to_layer) {
 458   if (paint_to_layer_ == paint_to_layer)
 459     return;
 460
 461   paint_to_layer_ = paint_to_layer;
 462   if (paint_to_layer_ && !layer()) {
 463     CreateLayer();
 464   } else if (!paint_to_layer_ && layer()) {
 465     DestroyLayer();
 466   }
 467 }
 468
 469 // RTL positioning -------------------------------------------------------------
 470
 471 gfx::Rect View::GetMirroredBounds() const {
 472   gfx::Rect bounds(bounds_);
 473   bounds.set_x(GetMirroredX());
 474   return bounds;
 475 }
 476
 477 gfx::Point View::GetMirroredPosition() const {
 478   return gfx::Point(GetMirroredX(), y());
 479 }
 480
 481 int View::GetMirroredX() const {
 482   return parent_ ? parent_->GetMirroredXForRect(bounds_) : x();
 483 }
 484
 485 int View::GetMirroredXForRect(const gfx::Rect& bounds) const {
 486   return base::i18n::IsRTL() ?
 487       (width() - bounds.x() - bounds.width()) : bounds.x();
 488 }
 489
 490 int View::GetMirroredXInView(int x) const {
 491   return base::i18n::IsRTL() ? width() - x : x;
 492 }
 493
 494 int View::GetMirroredXWithWidthInView(int x, int w) const {
 495   return base::i18n::IsRTL() ? width() - x - w : x;
 496 }
 497
 498 // Layout ----------------------------------------------------------------------
 499
 500 void View::Layout() {
 501   needs_layout_ = false;
 502
 503   // If we have a layout manager, let it handle the layout for us.
 504   if (layout_manager_.get())
 505     layout_manager_->Layout(this);
 506
 507   // Make sure to propagate the Layout() call to any children that haven't
 508   // received it yet through the layout manager and need to be laid out. This
 509   // is needed for the case when the child requires a layout but its bounds
 510   // weren't changed by the layout manager. If there is no layout manager, we
 511   // just propagate the Layout() call down the hierarchy, so whoever receives
 512   // the call can take appropriate action.
 513   for (int i = 0, count = child_count(); i < count; ++i) {
 514     View* child = child_at(i);
 515     if (child->needs_layout_ || !layout_manager_.get()) {
 516       TRACE_EVENT1("views", "View::Layout", "class", child->GetClassName());
 517       child->needs_layout_ = false;
 518       child->Layout();
 519     }
 520   }
 521 }
 522
 523 void View::InvalidateLayout() {
 524   // Always invalidate up. This is needed to handle the case of us already being
 525   // valid, but not our parent.
 526   needs_layout_ = true;
 527   if (parent_)
 528     parent_->InvalidateLayout();
 529 }
 530
 531 LayoutManager* View::GetLayoutManager() const {
 532   return layout_manager_.get();
 533 }
 534
 535 void View::SetLayoutManager(LayoutManager* layout_manager) {
 536   if (layout_manager_.get())
 537     layout_manager_->Uninstalled(this);
 538
 539   layout_manager_.reset(layout_manager);
 540   if (layout_manager_.get())
 541     layout_manager_->Installed(this);
 542 }
 543
 544 void View::SnapLayerToPixelBoundary() {
 545   if (!layer())
 546     return;
 547
 548   if (snap_layer_to_pixel_boundary_ && layer()->parent() &&
 549       layer()->GetCompositor()) {
 550     ui::SnapLayerToPhysicalPixelBoundary(layer()->parent(), layer());
 551   } else {
 552     // Reset the offset.
 553     layer()->SetSubpixelPositionOffset(gfx::Vector2dF());
 554   }
 555 }
 556
 557 // Attributes ------------------------------------------------------------------
 558
 559 const char* View::GetClassName() const {
 560   return kViewClassName;
 561 }
 562
 563 const View* View::GetAncestorWithClassName(const std::string& name) const {
 564   for (const View* view = this; view; view = view->parent_) {
 565     if (!strcmp(view->GetClassName(), name.c_str()))
 566       return view;
 567   }
 568   return NULL;
 569 }
 570
 571 View* View::GetAncestorWithClassName(const std::string& name) {
 572   return const_cast<View*>(const_cast<const View*>(this)->
 573       GetAncestorWithClassName(name));
 574 }
 575
 576 const View* View::GetViewByID(int id) const {
 577   if (id == id_)
 578     return const_cast<View*>(this);
 579
 580   for (int i = 0, count = child_count(); i < count; ++i) {
 581     const View* view = child_at(i)->GetViewByID(id);
 582     if (view)
 583       return view;
 584   }
 585   return NULL;
 586 }
 587
 588 View* View::GetViewByID(int id) {
 589   return const_cast<View*>(const_cast<const View*>(this)->GetViewByID(id));
 590 }
 591
 592 void View::SetGroup(int gid) {
 593   // Don't change the group id once it's set.
 594   DCHECK(group_ == -1 || group_ == gid);
 595   group_ = gid;
 596 }
 597
 598 int View::GetGroup() const {
 599   return group_;
 600 }
 601
 602 bool View::IsGroupFocusTraversable() const {
 603   return true;
 604 }
 605
 606 void View::GetViewsInGroup(int group, Views* views) {
 607   if (group_ == group)
 608     views->push_back(this);
 609
 610   for (int i = 0, count = child_count(); i < count; ++i)
 611     child_at(i)->GetViewsInGroup(group, views);
 612 }
 613
 614 View* View::GetSelectedViewForGroup(int group) {
 615   Views views;
 616   GetWidget()->GetRootView()->GetViewsInGroup(group, &views);
 617   return views.empty() ? NULL : views[0];
 618 }
 619
 620 // Coordinate conversion -------------------------------------------------------
 621
 622 // static
 623 void View::ConvertPointToTarget(const View* source,
 624                                 const View* target,
 625                                 gfx::Point* point) {
 626   DCHECK(source);
 627   DCHECK(target);
 628   if (source == target)
 629     return;
 630
 631   const View* root = GetHierarchyRoot(target);
 632   CHECK_EQ(GetHierarchyRoot(source), root);
 633
 634   if (source != root)
 635     source->ConvertPointForAncestor(root, point);
 636
 637   if (target != root)
 638     target->ConvertPointFromAncestor(root, point);
 639 }
 640
 641 // static
 642 void View::ConvertRectToTarget(const View* source,
 643                                const View* target,
 644                                gfx::RectF* rect) {
 645   DCHECK(source);
 646   DCHECK(target);
 647   if (source == target)
 648     return;
 649
 650   const View* root = GetHierarchyRoot(target);
 651   CHECK_EQ(GetHierarchyRoot(source), root);
 652
 653   if (source != root)
 654     source->ConvertRectForAncestor(root, rect);
 655
 656   if (target != root)
 657     target->ConvertRectFromAncestor(root, rect);
 658 }
 659
 660 // static
 661 void View::ConvertPointToWidget(const View* src, gfx::Point* p) {
 662   DCHECK(src);
 663   DCHECK(p);
 664
 665   src->ConvertPointForAncestor(NULL, p);
 666 }
 667
 668 // static
 669 void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) {
 670   DCHECK(dest);
 671   DCHECK(p);
 672
 673   dest->ConvertPointFromAncestor(NULL, p);
 674 }
 675
 676 // static
 677 void View::ConvertPointToScreen(const View* src, gfx::Point* p) {
 678   DCHECK(src);
 679   DCHECK(p);
 680
 681   // If the view is not connected to a tree, there's nothing we can do.
 682   const Widget* widget = src->GetWidget();
 683   if (widget) {
 684     ConvertPointToWidget(src, p);
 685     *p += widget->GetClientAreaBoundsInScreen().OffsetFromOrigin();
 686   }
 687 }
 688
 689 // static
 690 void View::ConvertPointFromScreen(const View* dst, gfx::Point* p) {
 691   DCHECK(dst);
 692   DCHECK(p);
 693
 694   const views::Widget* widget = dst->GetWidget();
 695   if (!widget)
 696     return;
 697   *p -= widget->GetClientAreaBoundsInScreen().OffsetFromOrigin();
 698   views::View::ConvertPointFromWidget(dst, p);
 699 }
 700
 701 gfx::Rect View::ConvertRectToParent(const gfx::Rect& rect) const {
 702   gfx::RectF x_rect = rect;
 703   GetTransform().TransformRect(&x_rect);
 704   x_rect.Offset(GetMirroredPosition().OffsetFromOrigin());
 705   // Pixels we partially occupy in the parent should be included.
 706   return gfx::ToEnclosingRect(x_rect);
 707 }
 708
 709 gfx::Rect View::ConvertRectToWidget(const gfx::Rect& rect) const {
 710   gfx::Rect x_rect = rect;
 711   for (const View* v = this; v; v = v->parent_)
 712     x_rect = v->ConvertRectToParent(x_rect);
 713   return x_rect;
 714 }
 715
 716 // Painting --------------------------------------------------------------------
 717
 718 void View::SchedulePaint() {
 719   SchedulePaintInRect(GetLocalBounds());
 720 }
 721
 722 void View::SchedulePaintInRect(const gfx::Rect& rect) {
 723   if (!visible_)
 724     return;
 725
 726   if (layer()) {
 727     layer()->SchedulePaint(rect);
 728   } else if (parent_) {
 729     // Translate the requested paint rect to the parent's coordinate system
 730     // then pass this notification up to the parent.
 731     parent_->SchedulePaintInRect(ConvertRectToParent(rect));
 732   }
 733 }
 734
 735 void View::Paint(const ui::PaintContext& parent_context) {
 736   if (!visible_)
 737     return;
 738   if (size().IsEmpty())
 739     return;
 740
 741   gfx::Vector2d offset_to_parent;
 742   if (!layer()) {
 743     // If the View has a layer() then it is a paint root. Otherwise, we need to
 744     // add the offset from the parent into the total offset from the paint root.
 745     DCHECK_IMPLIES(!parent(), bounds().origin() == gfx::Point());
 746     offset_to_parent = GetMirroredPosition().OffsetFromOrigin();
 747   }
 748   ui::PaintContext context(parent_context, offset_to_parent);
 749
 750   bool is_invalidated = true;
 751   if (context.CanCheckInvalid()) {
 752 #if DCHECK_IS_ON()
 753     gfx::Vector2d offset;
 754     context.Visited(this);
 755     View* view = this;
 756     while (view->parent() && !view->layer()) {
 757       DCHECK(view->GetTransform().IsIdentity());
 758       offset += view->GetMirroredPosition().OffsetFromOrigin();
 759       view = view->parent();
 760     }
 761     // The offset in the PaintContext should be the offset up to the paint root,
 762     // which we compute and verify here.
 763     DCHECK_EQ(context.PaintOffset().x(), offset.x());
 764     DCHECK_EQ(context.PaintOffset().y(), offset.y());
 765     // The above loop will stop when |view| is the paint root, which should be
 766     // the root of the current paint walk, as verified by storing the root in
 767     // the PaintContext.
 768     DCHECK_EQ(context.RootVisited(), view);
 769 #endif
 770
 771     // If the View wasn't invalidated, don't waste time painting it, the output
 772     // would be culled.
 773     is_invalidated = context.IsRectInvalid(GetLocalBounds());
 774   }
 775
 776   TRACE_EVENT1("views", "View::Paint", "class", GetClassName());
 777
 778   // If the view is backed by a layer, it should paint with itself as the origin
 779   // rather than relative to its parent.
 780   ui::ClipTransformRecorder clip_transform_recorder(context);
 781   if (!layer()) {
 782     // Set the clip rect to the bounds of this View. Note that the X (or left)
 783     // position we pass to ClipRect takes into consideration whether or not the
 784     // View uses a right-to-left layout so that we paint the View in its
 785     // mirrored position if need be.
 786     gfx::Rect clip_rect_in_parent = bounds();
 787     clip_rect_in_parent.Inset(clip_insets_);
 788     if (parent_)
 789       clip_rect_in_parent.set_x(
 790           parent_->GetMirroredXForRect(clip_rect_in_parent));
 791     clip_transform_recorder.ClipRect(clip_rect_in_parent);
 792
 793     // Translate the graphics such that 0,0 corresponds to where
 794     // this View is located relative to its parent.
 795     gfx::Transform transform_from_parent;
 796     gfx::Vector2d offset_from_parent = GetMirroredPosition().OffsetFromOrigin();
 797     transform_from_parent.Translate(offset_from_parent.x(),
 798                                     offset_from_parent.y());
 799     transform_from_parent.PreconcatTransform(GetTransform());
 800     clip_transform_recorder.Transform(transform_from_parent);
 801   }
 802
 803   if (is_invalidated || !paint_cache_.UseCache(context)) {
 804     ui::PaintRecorder recorder(context, size(), &paint_cache_);
 805     gfx::Canvas* canvas = recorder.canvas();
 806
 807     // If the View we are about to paint requested the canvas to be flipped, we
 808     // should change the transform appropriately.
 809     // The canvas mirroring is undone once the View is done painting so that we
 810     // don't pass the canvas with the mirrored transform to Views that didn't
 811     // request the canvas to be flipped.
 812     if (FlipCanvasOnPaintForRTLUI()) {
 813       canvas->Translate(gfx::Vector2d(width(), 0));
 814       canvas->Scale(-1, 1);
 815     }
 816
 817     // Delegate painting the contents of the View to the virtual OnPaint method.
 818     OnPaint(canvas);
 819   }
 820
 821   // View::Paint() recursion over the subtree.
 822   PaintChildren(context);
 823 }
 824
 825 void View::set_background(Background* b) {
 826   background_.reset(b);
 827 }
 828
 829 void View::SetBorder(scoped_ptr<Border> b) { border_ = b.Pass(); }
 830
 831 ui::ThemeProvider* View::GetThemeProvider() const {
 832   const Widget* widget = GetWidget();
 833   return widget ? widget->GetThemeProvider() : NULL;
 834 }
 835
 836 const ui::NativeTheme* View::GetNativeTheme() const {
 837   const Widget* widget = GetWidget();
 838   return widget ? widget->GetNativeTheme() : ui::NativeTheme::instance();
 839 }
 840
 841 // Input -----------------------------------------------------------------------
 842
 843 View* View::GetEventHandlerForPoint(const gfx::Point& point) {
 844   return GetEventHandlerForRect(gfx::Rect(point, gfx::Size(1, 1)));
 845 }
 846
 847 View* View::GetEventHandlerForRect(const gfx::Rect& rect) {
 848   return GetEffectiveViewTargeter()->TargetForRect(this, rect);
 849 }
 850
 851 bool View::CanProcessEventsWithinSubtree() const {
 852   return true;
 853 }
 854
 855 View* View::GetTooltipHandlerForPoint(const gfx::Point& point) {
 856   // TODO(tdanderson): Move this implementation into ViewTargetDelegate.
 857   if (!HitTestPoint(point) || !CanProcessEventsWithinSubtree())
 858     return NULL;
 859
 860   // Walk the child Views recursively looking for the View that most
 861   // tightly encloses the specified point.
 862   for (int i = child_count() - 1; i >= 0; --i) {
 863     View* child = child_at(i);
 864     if (!child->visible())
 865       continue;
 866
 867     gfx::Point point_in_child_coords(point);
 868     ConvertPointToTarget(this, child, &point_in_child_coords);
 869     View* handler = child->GetTooltipHandlerForPoint(point_in_child_coords);
 870     if (handler)
 871       return handler;
 872   }
 873   return this;
 874 }
 875
 876 gfx::NativeCursor View::GetCursor(const ui::MouseEvent& event) {
 877 #if defined(OS_WIN)
 878   static ui::Cursor arrow;
 879   if (!arrow.platform())
 880     arrow.SetPlatformCursor(LoadCursor(NULL, IDC_ARROW));
 881   return arrow;
 882 #else
 883   return gfx::kNullCursor;
 884 #endif
 885 }
 886
 887 bool View::HitTestPoint(const gfx::Point& point) const {
 888   return HitTestRect(gfx::Rect(point, gfx::Size(1, 1)));
 889 }
 890
 891 bool View::HitTestRect(const gfx::Rect& rect) const {
 892   return GetEffectiveViewTargeter()->DoesIntersectRect(this, rect);
 893 }
 894
 895 bool View::IsMouseHovered() {
 896   // If we haven't yet been placed in an onscreen view hierarchy, we can't be
 897   // hovered.
 898   if (!GetWidget())
 899     return false;
 900
 901   // If mouse events are disabled, then the mouse cursor is invisible and
 902   // is therefore not hovering over this button.
 903   if (!GetWidget()->IsMouseEventsEnabled())
 904     return false;
 905
 906   gfx::Point cursor_pos(gfx::Screen::GetScreenFor(
 907       GetWidget()->GetNativeView())->GetCursorScreenPoint());
 908   ConvertPointFromScreen(this, &cursor_pos);
 909   return HitTestPoint(cursor_pos);
 910 }
 911
 912 bool View::OnMousePressed(const ui::MouseEvent& event) {
 913   return false;
 914 }
 915
 916 bool View::OnMouseDragged(const ui::MouseEvent& event) {
 917   return false;
 918 }
 919
 920 void View::OnMouseReleased(const ui::MouseEvent& event) {
 921 }
 922
 923 void View::OnMouseCaptureLost() {
 924 }
 925
 926 void View::OnMouseMoved(const ui::MouseEvent& event) {
 927 }
 928
 929 void View::OnMouseEntered(const ui::MouseEvent& event) {
 930 }
 931
 932 void View::OnMouseExited(const ui::MouseEvent& event) {
 933 }
 934
 935 void View::SetMouseHandler(View* new_mouse_handler) {
 936   // |new_mouse_handler| may be NULL.
 937   if (parent_)
 938     parent_->SetMouseHandler(new_mouse_handler);
 939 }
 940
 941 bool View::OnKeyPressed(const ui::KeyEvent& event) {
 942   return false;
 943 }
 944
 945 bool View::OnKeyReleased(const ui::KeyEvent& event) {
 946   return false;
 947 }
 948
 949 bool View::OnMouseWheel(const ui::MouseWheelEvent& event) {
 950   return false;
 951 }
 952
 953 void View::OnKeyEvent(ui::KeyEvent* event) {
 954   bool consumed = (event->type() == ui::ET_KEY_PRESSED) ? OnKeyPressed(*event) :
 955                                                           OnKeyReleased(*event);
 956   if (consumed)
 957     event->StopPropagation();
 958 }
 959
 960 void View::OnMouseEvent(ui::MouseEvent* event) {
 961   switch (event->type()) {
 962     case ui::ET_MOUSE_PRESSED:
 963       if (ProcessMousePressed(*event))
 964         event->SetHandled();
 965       return;
 966
 967     case ui::ET_MOUSE_MOVED:
 968       if ((event->flags() & (ui::EF_LEFT_MOUSE_BUTTON |
 969                              ui::EF_RIGHT_MOUSE_BUTTON |
 970                              ui::EF_MIDDLE_MOUSE_BUTTON)) == 0) {
 971         OnMouseMoved(*event);
 972         return;
 973       }
 974       // FALL-THROUGH
 975     case ui::ET_MOUSE_DRAGGED:
 976       if (ProcessMouseDragged(*event))
 977         event->SetHandled();
 978       return;
 979
 980     case ui::ET_MOUSE_RELEASED:
 981       ProcessMouseReleased(*event);
 982       return;
 983
 984     case ui::ET_MOUSEWHEEL:
 985       if (OnMouseWheel(*static_cast<ui::MouseWheelEvent*>(event)))
 986         event->SetHandled();
 987       break;
 988
 989     case ui::ET_MOUSE_ENTERED:
 990       if (event->flags() & ui::EF_TOUCH_ACCESSIBILITY)
 991         NotifyAccessibilityEvent(ui::AX_EVENT_HOVER, true);
 992       OnMouseEntered(*event);
 993       break;
 994
 995     case ui::ET_MOUSE_EXITED:
 996       OnMouseExited(*event);
 997       break;
 998
 999     default:
1000       return;
1001   }
1002 }
1003
1004 void View::OnScrollEvent(ui::ScrollEvent* event) {
1005 }
1006
1007 void View::OnTouchEvent(ui::TouchEvent* event) {
1008   NOTREACHED() << "Views should not receive touch events.";
1009 }
1010
1011 void View::OnGestureEvent(ui::GestureEvent* event) {
1012 }
1013
1014 const ui::InputMethod* View::GetInputMethod() const {
1015   Widget* widget = const_cast<Widget*>(GetWidget());
1016   return widget ? const_cast<const ui::InputMethod*>(widget->GetInputMethod())
1017                 : nullptr;
1018 }
1019
1020 scoped_ptr<ViewTargeter>
1021 View::SetEventTargeter(scoped_ptr<ViewTargeter> targeter) {
1022   scoped_ptr<ViewTargeter> old_targeter = targeter_.Pass();
1023   targeter_ = targeter.Pass();
1024   return old_targeter.Pass();
1025 }
1026
1027 ViewTargeter* View::GetEffectiveViewTargeter() const {
1028   DCHECK(GetWidget());
1029   ViewTargeter* view_targeter = targeter();
1030   if (!view_targeter)
1031     view_targeter = GetWidget()->GetRootView()->targeter();
1032   CHECK(view_targeter);
1033   return view_targeter;
1034 }
1035
1036 bool View::CanAcceptEvent(const ui::Event& event) {
1037   return IsDrawn();
1038 }
1039
1040 ui::EventTarget* View::GetParentTarget() {
1041   return parent_;
1042 }
1043
1044 scoped_ptr<ui::EventTargetIterator> View::GetChildIterator() const {
1045   return make_scoped_ptr(new ui::EventTargetIteratorImpl<View>(children_));
1046 }
1047
1048 ui::EventTargeter* View::GetEventTargeter() {
1049   return targeter_.get();
1050 }
1051
1052 void View::ConvertEventToTarget(ui::EventTarget* target,
1053                                 ui::LocatedEvent* event) {
1054   event->ConvertLocationToTarget(this, static_cast<View*>(target));
1055 }
1056
1057 // Accelerators ----------------------------------------------------------------
1058
1059 void View::AddAccelerator(const ui::Accelerator& accelerator) {
1060   if (!accelerators_.get())
1061     accelerators_.reset(new std::vector<ui::Accelerator>());
1062
1063   if (std::find(accelerators_->begin(), accelerators_->end(), accelerator) ==
1064       accelerators_->end()) {
1065     accelerators_->push_back(accelerator);
1066   }
1067   RegisterPendingAccelerators();
1068 }
1069
1070 void View::RemoveAccelerator(const ui::Accelerator& accelerator) {
1071   if (!accelerators_.get()) {
1072     NOTREACHED() << "Removing non-existing accelerator";
1073     return;
1074   }
1075
1076   std::vector<ui::Accelerator>::iterator i(
1077       std::find(accelerators_->begin(), accelerators_->end(), accelerator));
1078   if (i == accelerators_->end()) {
1079     NOTREACHED() << "Removing non-existing accelerator";
1080     return;
1081   }
1082
1083   size_t index = i - accelerators_->begin();
1084   accelerators_->erase(i);
1085   if (index >= registered_accelerator_count_) {
1086     // The accelerator is not registered to FocusManager.
1087     return;
1088   }
1089   --registered_accelerator_count_;
1090
1091   // Providing we are attached to a Widget and registered with a focus manager,
1092   // we should de-register from that focus manager now.
1093   if (GetWidget() && accelerator_focus_manager_)
1094     accelerator_focus_manager_->UnregisterAccelerator(accelerator, this);
1095 }
1096
1097 void View::ResetAccelerators() {
1098   if (accelerators_.get())
1099     UnregisterAccelerators(false);
1100 }
1101
1102 bool View::AcceleratorPressed(const ui::Accelerator& accelerator) {
1103   return false;
1104 }
1105
1106 bool View::CanHandleAccelerators() const {
1107   return enabled() && IsDrawn() && GetWidget() && GetWidget()->IsVisible();
1108 }
1109
1110 // Focus -----------------------------------------------------------------------
1111
1112 bool View::HasFocus() const {
1113   const FocusManager* focus_manager = GetFocusManager();
1114   return focus_manager && (focus_manager->GetFocusedView() == this);
1115 }
1116
1117 View* View::GetNextFocusableView() {
1118   return next_focusable_view_;
1119 }
1120
1121 const View* View::GetNextFocusableView() const {
1122   return next_focusable_view_;
1123 }
1124
1125 View* View::GetPreviousFocusableView() {
1126   return previous_focusable_view_;
1127 }
1128
1129 void View::SetNextFocusableView(View* view) {
1130   if (view)
1131     view->previous_focusable_view_ = this;
1132   next_focusable_view_ = view;
1133 }
1134
1135 void View::SetFocusable(bool focusable) {
1136   if (focusable_ == focusable)
1137     return;
1138
1139   focusable_ = focusable;
1140   AdvanceFocusIfNecessary();
1141 }
1142
1143 bool View::IsFocusable() const {
1144   return focusable_ && enabled_ && IsDrawn();
1145 }
1146
1147 bool View::IsAccessibilityFocusable() const {
1148   return (focusable_ || accessibility_focusable_) && enabled_ && IsDrawn();
1149 }
1150
1151 void View::SetAccessibilityFocusable(bool accessibility_focusable) {
1152   if (accessibility_focusable_ == accessibility_focusable)
1153     return;
1154
1155   accessibility_focusable_ = accessibility_focusable;
1156   AdvanceFocusIfNecessary();
1157 }
1158
1159 FocusManager* View::GetFocusManager() {
1160   Widget* widget = GetWidget();
1161   return widget ? widget->GetFocusManager() : NULL;
1162 }
1163
1164 const FocusManager* View::GetFocusManager() const {
1165   const Widget* widget = GetWidget();
1166   return widget ? widget->GetFocusManager() : NULL;
1167 }
1168
1169 void View::RequestFocus() {
1170   FocusManager* focus_manager = GetFocusManager();
1171   if (focus_manager && IsFocusable())
1172     focus_manager->SetFocusedView(this);
1173 }
1174
1175 bool View::SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) {
1176   return false;
1177 }
1178
1179 FocusTraversable* View::GetFocusTraversable() {
1180   return NULL;
1181 }
1182
1183 FocusTraversable* View::GetPaneFocusTraversable() {
1184   return NULL;
1185 }
1186
1187 // Tooltips --------------------------------------------------------------------
1188
1189 bool View::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
1190   return false;
1191 }
1192
1193 bool View::GetTooltipTextOrigin(const gfx::Point& p, gfx::Point* loc) const {
1194   return false;
1195 }
1196
1197 // Context menus ---------------------------------------------------------------
1198
1199 void View::ShowContextMenu(const gfx::Point& p,
1200                            ui::MenuSourceType source_type) {
1201   if (!context_menu_controller_)
1202     return;
1203
1204   context_menu_controller_->ShowContextMenuForView(this, p, source_type);
1205 }
1206
1207 // static
1208 bool View::ShouldShowContextMenuOnMousePress() {
1209   return kContextMenuOnMousePress;
1210 }
1211
1212 gfx::Point View::GetKeyboardContextMenuLocation() {
1213   gfx::Rect vis_bounds = GetVisibleBounds();
1214   gfx::Point screen_point(vis_bounds.x() + vis_bounds.width() / 2,
1215                           vis_bounds.y() + vis_bounds.height() / 2);
1216   ConvertPointToScreen(this, &screen_point);
1217   return screen_point;
1218 }
1219
1220 // Drag and drop ---------------------------------------------------------------
1221
1222 bool View::GetDropFormats(
1223       int* formats,
1224       std::set<OSExchangeData::CustomFormat>* custom_formats) {
1225   return false;
1226 }
1227
1228 bool View::AreDropTypesRequired() {
1229   return false;
1230 }
1231
1232 bool View::CanDrop(const OSExchangeData& data) {
1233   // TODO(sky): when I finish up migration, this should default to true.
1234   return false;
1235 }
1236
1237 void View::OnDragEntered(const ui::DropTargetEvent& event) {
1238 }
1239
1240 int View::OnDragUpdated(const ui::DropTargetEvent& event) {
1241   return ui::DragDropTypes::DRAG_NONE;
1242 }
1243
1244 void View::OnDragExited() {
1245 }
1246
1247 int View::OnPerformDrop(const ui::DropTargetEvent& event) {
1248   return ui::DragDropTypes::DRAG_NONE;
1249 }
1250
1251 void View::OnDragDone() {
1252 }
1253
1254 // static
1255 bool View::ExceededDragThreshold(const gfx::Vector2d& delta) {
1256   return (abs(delta.x()) > GetHorizontalDragThreshold() ||
1257           abs(delta.y()) > GetVerticalDragThreshold());
1258 }
1259
1260 // Accessibility----------------------------------------------------------------
1261
1262 gfx::NativeViewAccessible View::GetNativeViewAccessible() {
1263   if (!native_view_accessibility_)
1264     native_view_accessibility_ = NativeViewAccessibility::Create(this);
1265   if (native_view_accessibility_)
1266     return native_view_accessibility_->GetNativeObject();
1267   return NULL;
1268 }
1269
1270 void View::NotifyAccessibilityEvent(
1271     ui::AXEvent event_type,
1272     bool send_native_event) {
1273   if (ViewsDelegate::GetInstance())
1274     ViewsDelegate::GetInstance()->NotifyAccessibilityEvent(this, event_type);
1275
1276   if (send_native_event && GetWidget()) {
1277     if (!native_view_accessibility_)
1278       native_view_accessibility_ = NativeViewAccessibility::Create(this);
1279     if (native_view_accessibility_)
1280       native_view_accessibility_->NotifyAccessibilityEvent(event_type);
1281   }
1282 }
1283
1284 // Scrolling -------------------------------------------------------------------
1285
1286 void View::ScrollRectToVisible(const gfx::Rect& rect) {
1287   // We must take RTL UI mirroring into account when adjusting the position of
1288   // the region.
1289   if (parent_) {
1290     gfx::Rect scroll_rect(rect);
1291     scroll_rect.Offset(GetMirroredX(), y());
1292     parent_->ScrollRectToVisible(scroll_rect);
1293   }
1294 }
1295
1296 int View::GetPageScrollIncrement(ScrollView* scroll_view,
1297                                  bool is_horizontal, bool is_positive) {
1298   return 0;
1299 }
1300
1301 int View::GetLineScrollIncrement(ScrollView* scroll_view,
1302                                  bool is_horizontal, bool is_positive) {
1303   return 0;
1304 }
1305
1306 ////////////////////////////////////////////////////////////////////////////////
1307 // View, protected:
1308
1309 // Size and disposition --------------------------------------------------------
1310
1311 void View::OnBoundsChanged(const gfx::Rect& previous_bounds) {
1312 }
1313
1314 void View::PreferredSizeChanged() {
1315   InvalidateLayout();
1316   if (parent_)
1317     parent_->ChildPreferredSizeChanged(this);
1318 }
1319
1320 bool View::GetNeedsNotificationWhenVisibleBoundsChange() const {
1321   return false;
1322 }
1323
1324 void View::OnVisibleBoundsChanged() {
1325 }
1326
1327 // Tree operations -------------------------------------------------------------
1328
1329 void View::ViewHierarchyChanged(const ViewHierarchyChangedDetails& details) {
1330 }
1331
1332 void View::VisibilityChanged(View* starting_from, bool is_visible) {
1333 }
1334
1335 void View::NativeViewHierarchyChanged() {
1336   FocusManager* focus_manager = GetFocusManager();
1337   if (accelerator_focus_manager_ != focus_manager) {
1338     UnregisterAccelerators(true);
1339
1340     if (focus_manager)
1341       RegisterPendingAccelerators();
1342   }
1343 }
1344
1345 // Painting --------------------------------------------------------------------
1346
1347 void View::PaintChildren(const ui::PaintContext& context) {
1348   TRACE_EVENT1("views", "View::PaintChildren", "class", GetClassName());
1349   for (int i = 0, count = child_count(); i < count; ++i)
1350     if (!child_at(i)->layer())
1351       child_at(i)->Paint(context);
1352 }
1353
1354 void View::OnPaint(gfx::Canvas* canvas) {
1355   TRACE_EVENT1("views", "View::OnPaint", "class", GetClassName());
1356   OnPaintBackground(canvas);
1357   OnPaintBorder(canvas);
1358 }
1359
1360 void View::OnPaintBackground(gfx::Canvas* canvas) {
1361   if (background_.get()) {
1362     TRACE_EVENT2("views", "View::OnPaintBackground",
1363                  "width", canvas->sk_canvas()->getDevice()->width(),
1364                  "height", canvas->sk_canvas()->getDevice()->height());
1365     background_->Paint(canvas, this);
1366   }
1367 }
1368
1369 void View::OnPaintBorder(gfx::Canvas* canvas) {
1370   if (border_.get()) {
1371     TRACE_EVENT2("views", "View::OnPaintBorder",
1372                  "width", canvas->sk_canvas()->getDevice()->width(),
1373                  "height", canvas->sk_canvas()->getDevice()->height());
1374     border_->Paint(*this, canvas);
1375   }
1376 }
1377
1378 // Accelerated Painting --------------------------------------------------------
1379
1380 void View::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
1381   // This method should not have the side-effect of creating the layer.
1382   if (layer())
1383     layer()->SetFillsBoundsOpaquely(fills_bounds_opaquely);
1384 }
1385
1386 gfx::Vector2d View::CalculateOffsetToAncestorWithLayer(
1387     ui::Layer** layer_parent) {
1388   if (layer()) {
1389     if (layer_parent)
1390       *layer_parent = layer();
1391     return gfx::Vector2d();
1392   }
1393   if (!parent_)
1394     return gfx::Vector2d();
1395
1396   return gfx::Vector2d(GetMirroredX(), y()) +
1397       parent_->CalculateOffsetToAncestorWithLayer(layer_parent);
1398 }
1399
1400 void View::UpdateParentLayer() {
1401   if (!layer())
1402     return;
1403
1404   ui::Layer* parent_layer = NULL;
1405   gfx::Vector2d offset(GetMirroredX(), y());
1406
1407   if (parent_)
1408     offset += parent_->CalculateOffsetToAncestorWithLayer(&parent_layer);
1409
1410   ReparentLayer(offset, parent_layer);
1411 }
1412
1413 void View::MoveLayerToParent(ui::Layer* parent_layer,
1414                              const gfx::Point& point) {
1415   gfx::Point local_point(point);
1416   if (parent_layer != layer())
1417     local_point.Offset(GetMirroredX(), y());
1418   if (layer() && parent_layer != layer()) {
1419     parent_layer->Add(layer());
1420     SetLayerBounds(gfx::Rect(local_point.x(), local_point.y(),
1421                              width(), height()));
1422   } else {
1423     for (int i = 0, count = child_count(); i < count; ++i)
1424       child_at(i)->MoveLayerToParent(parent_layer, local_point);
1425   }
1426 }
1427
1428 void View::UpdateLayerVisibility() {
1429   bool visible = visible_;
1430   for (const View* v = parent_; visible && v && !v->layer(); v = v->parent_)
1431     visible = v->visible();
1432
1433   UpdateChildLayerVisibility(visible);
1434 }
1435
1436 void View::UpdateChildLayerVisibility(bool ancestor_visible) {
1437   if (layer()) {
1438     layer()->SetVisible(ancestor_visible && visible_);
1439   } else {
1440     for (int i = 0, count = child_count(); i < count; ++i)
1441       child_at(i)->UpdateChildLayerVisibility(ancestor_visible && visible_);
1442   }
1443 }
1444
1445 void View::UpdateChildLayerBounds(const gfx::Vector2d& offset) {
1446   if (layer()) {
1447     SetLayerBounds(GetLocalBounds() + offset);
1448   } else {
1449     for (int i = 0, count = child_count(); i < count; ++i) {
1450       View* child = child_at(i);
1451       child->UpdateChildLayerBounds(
1452           offset + gfx::Vector2d(child->GetMirroredX(), child->y()));
1453     }
1454   }
1455 }
1456
1457 void View::OnPaintLayer(const ui::PaintContext& context) {
1458   Paint(context);
1459 }
1460
1461 void View::OnDelegatedFrameDamage(
1462     const gfx::Rect& damage_rect_in_dip) {
1463 }
1464
1465 void View::OnDeviceScaleFactorChanged(float device_scale_factor) {
1466   snap_layer_to_pixel_boundary_ =
1467       (device_scale_factor - std::floor(device_scale_factor)) != 0.0f;
1468   SnapLayerToPixelBoundary();
1469   // Repainting with new scale factor will paint the content at the right scale.
1470 }
1471
1472 base::Closure View::PrepareForLayerBoundsChange() {
1473   return base::Closure();
1474 }
1475
1476 void View::ReorderLayers() {
1477   View* v = this;
1478   while (v && !v->layer())
1479     v = v->parent();
1480
1481   Widget* widget = GetWidget();
1482   if (!v) {
1483     if (widget) {
1484       ui::Layer* layer = widget->GetLayer();
1485       if (layer)
1486         widget->GetRootView()->ReorderChildLayers(layer);
1487     }
1488   } else {
1489     v->ReorderChildLayers(v->layer());
1490   }
1491
1492   if (widget) {
1493     // Reorder the widget's child NativeViews in case a child NativeView is
1494     // associated with a view (eg via a NativeViewHost). Always do the
1495     // reordering because the associated NativeView's layer (if it has one)
1496     // is parented to the widget's layer regardless of whether the host view has
1497     // an ancestor with a layer.
1498     widget->ReorderNativeViews();
1499   }
1500 }
1501
1502 void View::ReorderChildLayers(ui::Layer* parent_layer) {
1503   if (layer() && layer() != parent_layer) {
1504     DCHECK_EQ(parent_layer, layer()->parent());
1505     parent_layer->StackAtBottom(layer());
1506   } else {
1507     // Iterate backwards through the children so that a child with a layer
1508     // which is further to the back is stacked above one which is further to
1509     // the front.
1510     for (Views::reverse_iterator it(children_.rbegin());
1511          it != children_.rend(); ++it) {
1512       (*it)->ReorderChildLayers(parent_layer);
1513     }
1514   }
1515 }
1516
1517 // Input -----------------------------------------------------------------------
1518
1519 View::DragInfo* View::GetDragInfo() {
1520   return parent_ ? parent_->GetDragInfo() : NULL;
1521 }
1522
1523 // Focus -----------------------------------------------------------------------
1524
1525 void View::OnFocus() {
1526   // TODO(beng): Investigate whether it's possible for us to move this to
1527   //             Focus().
1528   // By default, we clear the native focus. This ensures that no visible native
1529   // view as the focus and that we still receive keyboard inputs.
1530   FocusManager* focus_manager = GetFocusManager();
1531   if (focus_manager)
1532     focus_manager->ClearNativeFocus();
1533
1534   // TODO(beng): Investigate whether it's possible for us to move this to
1535   //             Focus().
1536   // Notify assistive technologies of the focus change.
1537   NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, true);
1538 }
1539
1540 void View::OnBlur() {
1541 }
1542
1543 void View::Focus() {
1544   OnFocus();
1545 }
1546
1547 void View::Blur() {
1548   OnBlur();
1549 }
1550
1551 // Tooltips --------------------------------------------------------------------
1552
1553 void View::TooltipTextChanged() {
1554   Widget* widget = GetWidget();
1555   // TooltipManager may be null if there is a problem creating it.
1556   if (widget && widget->GetTooltipManager())
1557     widget->GetTooltipManager()->TooltipTextChanged(this);
1558 }
1559
1560 // Drag and drop ---------------------------------------------------------------
1561
1562 int View::GetDragOperations(const gfx::Point& press_pt) {
1563   return drag_controller_ ?
1564       drag_controller_->GetDragOperationsForView(this, press_pt) :
1565       ui::DragDropTypes::DRAG_NONE;
1566 }
1567
1568 void View::WriteDragData(const gfx::Point& press_pt, OSExchangeData* data) {
1569   DCHECK(drag_controller_);
1570   drag_controller_->WriteDragDataForView(this, press_pt, data);
1571 }
1572
1573 bool View::InDrag() {
1574   Widget* widget = GetWidget();
1575   return widget ? widget->dragged_view() == this : false;
1576 }
1577
1578 int View::GetHorizontalDragThreshold() {
1579   // TODO(jennyz): This value may need to be adjusted for different platforms
1580   // and for different display density.
1581   return kDefaultHorizontalDragThreshold;
1582 }
1583
1584 int View::GetVerticalDragThreshold() {
1585   // TODO(jennyz): This value may need to be adjusted for different platforms
1586   // and for different display density.
1587   return kDefaultVerticalDragThreshold;
1588 }
1589
1590 // Debugging -------------------------------------------------------------------
1591
1592 #if !defined(NDEBUG)
1593
1594 std::string View::PrintViewGraph(bool first) {
1595   return DoPrintViewGraph(first, this);
1596 }
1597
1598 std::string View::DoPrintViewGraph(bool first, View* view_with_children) {
1599   // 64-bit pointer = 16 bytes of hex + "0x" + '\0' = 19.
1600   const size_t kMaxPointerStringLength = 19;
1601
1602   std::string result;
1603
1604   if (first)
1605     result.append("digraph {\n");
1606
1607   // Node characteristics.
1608   char p[kMaxPointerStringLength];
1609
1610   const std::string class_name(GetClassName());
1611   size_t base_name_index = class_name.find_last_of('/');
1612   if (base_name_index == std::string::npos)
1613     base_name_index = 0;
1614   else
1615     base_name_index++;
1616
1617   char bounds_buffer[512];
1618
1619   // Information about current node.
1620   base::snprintf(p, arraysize(bounds_buffer), "%p", view_with_children);
1621   result.append("  N");
1622   result.append(p + 2);
1623   result.append(" [label=\"");
1624
1625   result.append(class_name.substr(base_name_index).c_str());
1626
1627   base::snprintf(bounds_buffer,
1628                  arraysize(bounds_buffer),
1629                  "\\n bounds: (%d, %d), (%dx%d)",
1630                  bounds().x(),
1631                  bounds().y(),
1632                  bounds().width(),
1633                  bounds().height());
1634   result.append(bounds_buffer);
1635
1636   gfx::DecomposedTransform decomp;
1637   if (!GetTransform().IsIdentity() &&
1638       gfx::DecomposeTransform(&decomp, GetTransform())) {
1639     base::snprintf(bounds_buffer,
1640                    arraysize(bounds_buffer),
1641                    "\\n translation: (%f, %f)",
1642                    decomp.translate[0],
1643                    decomp.translate[1]);
1644     result.append(bounds_buffer);
1645
1646     base::snprintf(bounds_buffer,
1647                    arraysize(bounds_buffer),
1648                    "\\n rotation: %3.2f",
1649                    std::acos(decomp.quaternion[3]) * 360.0 / M_PI);
1650     result.append(bounds_buffer);
1651
1652     base::snprintf(bounds_buffer,
1653                    arraysize(bounds_buffer),
1654                    "\\n scale: (%2.4f, %2.4f)",
1655                    decomp.scale[0],
1656                    decomp.scale[1]);
1657     result.append(bounds_buffer);
1658   }
1659
1660   result.append("\"");
1661   if (!parent_)
1662     result.append(", shape=box");
1663   if (layer()) {
1664     if (layer()->has_external_content())
1665       result.append(", color=green");
1666     else
1667       result.append(", color=red");
1668
1669     if (layer()->fills_bounds_opaquely())
1670       result.append(", style=filled");
1671   }
1672   result.append("]\n");
1673
1674   // Link to parent.
1675   if (parent_) {
1676     char pp[kMaxPointerStringLength];
1677
1678     base::snprintf(pp, kMaxPointerStringLength, "%p", parent_);
1679     result.append("  N");
1680     result.append(pp + 2);
1681     result.append(" -> N");
1682     result.append(p + 2);
1683     result.append("\n");
1684   }
1685
1686   // Children.
1687   for (int i = 0, count = view_with_children->child_count(); i < count; ++i)
1688     result.append(view_with_children->child_at(i)->PrintViewGraph(false));
1689
1690   if (first)
1691     result.append("}\n");
1692
1693   return result;
1694 }
1695 #endif
1696
1697 ////////////////////////////////////////////////////////////////////////////////
1698 // View, private:
1699
1700 // DropInfo --------------------------------------------------------------------
1701
1702 void View::DragInfo::Reset() {
1703   possible_drag = false;
1704   start_pt = gfx::Point();
1705 }
1706
1707 void View::DragInfo::PossibleDrag(const gfx::Point& p) {
1708   possible_drag = true;
1709   start_pt = p;
1710 }
1711
1712 // Painting --------------------------------------------------------------------
1713
1714 void View::SchedulePaintBoundsChanged(SchedulePaintType type) {
1715   // If we have a layer and the View's size did not change, we do not need to
1716   // schedule any paints since the layer will be redrawn at its new location
1717   // during the next Draw() cycle in the compositor.
1718   if (!layer() || type == SCHEDULE_PAINT_SIZE_CHANGED) {
1719     // Otherwise, if the size changes or we don't have a layer then we need to
1720     // use SchedulePaint to invalidate the area occupied by the View.
1721     SchedulePaint();
1722   } else if (parent_ && type == SCHEDULE_PAINT_SIZE_SAME) {
1723     // The compositor doesn't Draw() until something on screen changes, so
1724     // if our position changes but nothing is being animated on screen, then
1725     // tell the compositor to redraw the scene. We know layer() exists due to
1726     // the above if clause.
1727     layer()->ScheduleDraw();
1728   }
1729 }
1730
1731 // Tree operations -------------------------------------------------------------
1732
1733 void View::DoRemoveChildView(View* view,
1734                              bool update_focus_cycle,
1735                              bool update_tool_tip,
1736                              bool delete_removed_view,
1737                              View* new_parent) {
1738   DCHECK(view);
1739
1740   const Views::iterator i(std::find(children_.begin(), children_.end(), view));
1741   scoped_ptr<View> view_to_be_deleted;
1742   if (i != children_.end()) {
1743     if (update_focus_cycle) {
1744       // Let's remove the view from the focus traversal.
1745       View* next_focusable = view->next_focusable_view_;
1746       View* prev_focusable = view->previous_focusable_view_;
1747       if (prev_focusable)
1748         prev_focusable->next_focusable_view_ = next_focusable;
1749       if (next_focusable)
1750         next_focusable->previous_focusable_view_ = prev_focusable;
1751     }
1752
1753     if (GetWidget()) {
1754       UnregisterChildrenForVisibleBoundsNotification(view);
1755       if (view->visible())
1756         view->SchedulePaint();
1757       GetWidget()->NotifyWillRemoveView(view);
1758     }
1759
1760     view->PropagateRemoveNotifications(this, new_parent);
1761     view->parent_ = NULL;
1762     view->UpdateLayerVisibility();
1763
1764     if (delete_removed_view && !view->owned_by_client_)
1765       view_to_be_deleted.reset(view);
1766
1767     children_.erase(i);
1768   }
1769
1770   if (update_tool_tip)
1771     UpdateTooltip();
1772
1773   if (layout_manager_.get())
1774     layout_manager_->ViewRemoved(this, view);
1775 }
1776
1777 void View::PropagateRemoveNotifications(View* old_parent, View* new_parent) {
1778   for (int i = 0, count = child_count(); i < count; ++i)
1779     child_at(i)->PropagateRemoveNotifications(old_parent, new_parent);
1780
1781   ViewHierarchyChangedDetails details(false, old_parent, this, new_parent);
1782   for (View* v = this; v; v = v->parent_)
1783     v->ViewHierarchyChangedImpl(true, details);
1784 }
1785
1786 void View::PropagateAddNotifications(
1787     const ViewHierarchyChangedDetails& details) {
1788   for (int i = 0, count = child_count(); i < count; ++i)
1789     child_at(i)->PropagateAddNotifications(details);
1790   ViewHierarchyChangedImpl(true, details);
1791 }
1792
1793 void View::PropagateNativeViewHierarchyChanged() {
1794   for (int i = 0, count = child_count(); i < count; ++i)
1795     child_at(i)->PropagateNativeViewHierarchyChanged();
1796   NativeViewHierarchyChanged();
1797 }
1798
1799 void View::ViewHierarchyChangedImpl(
1800     bool register_accelerators,
1801     const ViewHierarchyChangedDetails& details) {
1802   if (register_accelerators) {
1803     if (details.is_add) {
1804       // If you get this registration, you are part of a subtree that has been
1805       // added to the view hierarchy.
1806       if (GetFocusManager())
1807         RegisterPendingAccelerators();
1808     } else {
1809       if (details.child == this)
1810         UnregisterAccelerators(true);
1811     }
1812   }
1813
1814   if (details.is_add && layer() && !layer()->parent()) {
1815     UpdateParentLayer();
1816     Widget* widget = GetWidget();
1817     if (widget)
1818       widget->UpdateRootLayers();
1819   } else if (!details.is_add && details.child == this) {
1820     // Make sure the layers belonging to the subtree rooted at |child| get
1821     // removed from layers that do not belong in the same subtree.
1822     OrphanLayers();
1823     Widget* widget = GetWidget();
1824     if (widget)
1825       widget->UpdateRootLayers();
1826   }
1827
1828   ViewHierarchyChanged(details);
1829   details.parent->needs_layout_ = true;
1830 }
1831
1832 void View::PropagateNativeThemeChanged(const ui::NativeTheme* theme) {
1833   for (int i = 0, count = child_count(); i < count; ++i)
1834     child_at(i)->PropagateNativeThemeChanged(theme);
1835   OnNativeThemeChanged(theme);
1836 }
1837
1838 // Size and disposition --------------------------------------------------------
1839
1840 void View::PropagateVisibilityNotifications(View* start, bool is_visible) {
1841   for (int i = 0, count = child_count(); i < count; ++i)
1842     child_at(i)->PropagateVisibilityNotifications(start, is_visible);
1843   VisibilityChangedImpl(start, is_visible);
1844 }
1845
1846 void View::VisibilityChangedImpl(View* starting_from, bool is_visible) {
1847   VisibilityChanged(starting_from, is_visible);
1848 }
1849
1850 void View::BoundsChanged(const gfx::Rect& previous_bounds) {
1851   if (visible_) {
1852     // Paint the new bounds.
1853     SchedulePaintBoundsChanged(
1854         bounds_.size() == previous_bounds.size() ? SCHEDULE_PAINT_SIZE_SAME :
1855         SCHEDULE_PAINT_SIZE_CHANGED);
1856   }
1857
1858   if (layer()) {
1859     if (parent_) {
1860       SetLayerBounds(GetLocalBounds() +
1861                      gfx::Vector2d(GetMirroredX(), y()) +
1862                      parent_->CalculateOffsetToAncestorWithLayer(NULL));
1863     } else {
1864       SetLayerBounds(bounds_);
1865     }
1866
1867     // In RTL mode, if our width has changed, our children's mirrored bounds
1868     // will have changed. Update the child's layer bounds, or if it is not a
1869     // layer, the bounds of any layers inside the child.
1870     if (base::i18n::IsRTL() && bounds_.width() != previous_bounds.width()) {
1871       for (int i = 0; i < child_count(); ++i) {
1872         View* child = child_at(i);
1873         child->UpdateChildLayerBounds(
1874             gfx::Vector2d(child->GetMirroredX(), child->y()));
1875       }
1876     }
1877   } else {
1878     // If our bounds have changed, then any descendant layer bounds may have
1879     // changed. Update them accordingly.
1880     UpdateChildLayerBounds(CalculateOffsetToAncestorWithLayer(NULL));
1881   }
1882
1883   OnBoundsChanged(previous_bounds);
1884
1885   if (previous_bounds.size() != size()) {
1886     needs_layout_ = false;
1887     Layout();
1888   }
1889
1890   if (GetNeedsNotificationWhenVisibleBoundsChange())
1891     OnVisibleBoundsChanged();
1892
1893   // Notify interested Views that visible bounds within the root view may have
1894   // changed.
1895   if (descendants_to_notify_.get()) {
1896     for (Views::iterator i(descendants_to_notify_->begin());
1897          i != descendants_to_notify_->end(); ++i) {
1898       (*i)->OnVisibleBoundsChanged();
1899     }
1900   }
1901 }
1902
1903 // static
1904 void View::RegisterChildrenForVisibleBoundsNotification(View* view) {
1905   if (view->GetNeedsNotificationWhenVisibleBoundsChange())
1906     view->RegisterForVisibleBoundsNotification();
1907   for (int i = 0; i < view->child_count(); ++i)
1908     RegisterChildrenForVisibleBoundsNotification(view->child_at(i));
1909 }
1910
1911 // static
1912 void View::UnregisterChildrenForVisibleBoundsNotification(View* view) {
1913   if (view->GetNeedsNotificationWhenVisibleBoundsChange())
1914     view->UnregisterForVisibleBoundsNotification();
1915   for (int i = 0; i < view->child_count(); ++i)
1916     UnregisterChildrenForVisibleBoundsNotification(view->child_at(i));
1917 }
1918
1919 void View::RegisterForVisibleBoundsNotification() {
1920   if (registered_for_visible_bounds_notification_)
1921     return;
1922
1923   registered_for_visible_bounds_notification_ = true;
1924   for (View* ancestor = parent_; ancestor; ancestor = ancestor->parent_)
1925     ancestor->AddDescendantToNotify(this);
1926 }
1927
1928 void View::UnregisterForVisibleBoundsNotification() {
1929   if (!registered_for_visible_bounds_notification_)
1930     return;
1931
1932   registered_for_visible_bounds_notification_ = false;
1933   for (View* ancestor = parent_; ancestor; ancestor = ancestor->parent_)
1934     ancestor->RemoveDescendantToNotify(this);
1935 }
1936
1937 void View::AddDescendantToNotify(View* view) {
1938   DCHECK(view);
1939   if (!descendants_to_notify_.get())
1940     descendants_to_notify_.reset(new Views);
1941   descendants_to_notify_->push_back(view);
1942 }
1943
1944 void View::RemoveDescendantToNotify(View* view) {
1945   DCHECK(view && descendants_to_notify_.get());
1946   Views::iterator i(std::find(
1947       descendants_to_notify_->begin(), descendants_to_notify_->end(), view));
1948   DCHECK(i != descendants_to_notify_->end());
1949   descendants_to_notify_->erase(i);
1950   if (descendants_to_notify_->empty())
1951     descendants_to_notify_.reset();
1952 }
1953
1954 void View::SetLayerBounds(const gfx::Rect& bounds) {
1955   layer()->SetBounds(bounds);
1956   SnapLayerToPixelBoundary();
1957 }
1958
1959 // Transformations -------------------------------------------------------------
1960
1961 bool View::GetTransformRelativeTo(const View* ancestor,
1962                                   gfx::Transform* transform) const {
1963   const View* p = this;
1964
1965   while (p && p != ancestor) {
1966     transform->ConcatTransform(p->GetTransform());
1967     gfx::Transform translation;
1968     translation.Translate(static_cast<float>(p->GetMirroredX()),
1969                           static_cast<float>(p->y()));
1970     transform->ConcatTransform(translation);
1971
1972     p = p->parent_;
1973   }
1974
1975   return p == ancestor;
1976 }
1977
1978 // Coordinate conversion -------------------------------------------------------
1979
1980 bool View::ConvertPointForAncestor(const View* ancestor,
1981                                    gfx::Point* point) const {
1982   gfx::Transform trans;
1983   // TODO(sad): Have some way of caching the transformation results.
1984   bool result = GetTransformRelativeTo(ancestor, &trans);
1985   gfx::Point3F p(*point);
1986   trans.TransformPoint(&p);
1987   *point = gfx::ToFlooredPoint(p.AsPointF());
1988   return result;
1989 }
1990
1991 bool View::ConvertPointFromAncestor(const View* ancestor,
1992                                     gfx::Point* point) const {
1993   gfx::Transform trans;
1994   bool result = GetTransformRelativeTo(ancestor, &trans);
1995   gfx::Point3F p(*point);
1996   trans.TransformPointReverse(&p);
1997   *point = gfx::ToFlooredPoint(p.AsPointF());
1998   return result;
1999 }
2000
2001 bool View::ConvertRectForAncestor(const View* ancestor,
2002                                   gfx::RectF* rect) const {
2003   gfx::Transform trans;
2004   // TODO(sad): Have some way of caching the transformation results.
2005   bool result = GetTransformRelativeTo(ancestor, &trans);
2006   trans.TransformRect(rect);
2007   return result;
2008 }
2009
2010 bool View::ConvertRectFromAncestor(const View* ancestor,
2011                                    gfx::RectF* rect) const {
2012   gfx::Transform trans;
2013   bool result = GetTransformRelativeTo(ancestor, &trans);
2014   trans.TransformRectReverse(rect);
2015   return result;
2016 }
2017
2018 // Accelerated painting --------------------------------------------------------
2019
2020 void View::CreateLayer() {
2021   // A new layer is being created for the view. So all the layers of the
2022   // sub-tree can inherit the visibility of the corresponding view.
2023   for (int i = 0, count = child_count(); i < count; ++i)
2024     child_at(i)->UpdateChildLayerVisibility(true);
2025
2026   SetLayer(new ui::Layer());
2027   layer()->set_delegate(this);
2028 #if !defined(NDEBUG)
2029   layer()->set_name(GetClassName());
2030 #endif
2031
2032   UpdateParentLayers();
2033   UpdateLayerVisibility();
2034
2035   // The new layer needs to be ordered in the layer tree according
2036   // to the view tree. Children of this layer were added in order
2037   // in UpdateParentLayers().
2038   if (parent())
2039     parent()->ReorderLayers();
2040
2041   Widget* widget = GetWidget();
2042   if (widget)
2043     widget->UpdateRootLayers();
2044 }
2045
2046 void View::UpdateParentLayers() {
2047   // Attach all top-level un-parented layers.
2048   if (layer() && !layer()->parent()) {
2049     UpdateParentLayer();
2050   } else {
2051     for (int i = 0, count = child_count(); i < count; ++i)
2052       child_at(i)->UpdateParentLayers();
2053   }
2054 }
2055
2056 void View::OrphanLayers() {
2057   if (layer()) {
2058     if (layer()->parent())
2059       layer()->parent()->Remove(layer());
2060
2061     // The layer belonging to this View has already been orphaned. It is not
2062     // necessary to orphan the child layers.
2063     return;
2064   }
2065   for (int i = 0, count = child_count(); i < count; ++i)
2066     child_at(i)->OrphanLayers();
2067 }
2068
2069 void View::ReparentLayer(const gfx::Vector2d& offset, ui::Layer* parent_layer) {
2070   layer()->SetBounds(GetLocalBounds() + offset);
2071   DCHECK_NE(layer(), parent_layer);
2072   if (parent_layer)
2073     parent_layer->Add(layer());
2074   layer()->SchedulePaint(GetLocalBounds());
2075   MoveLayerToParent(layer(), gfx::Point());
2076 }
2077
2078 void View::DestroyLayer() {
2079   ui::Layer* new_parent = layer()->parent();
2080   std::vector<ui::Layer*> children = layer()->children();
2081   for (size_t i = 0; i < children.size(); ++i) {
2082     layer()->Remove(children[i]);
2083     if (new_parent)
2084       new_parent->Add(children[i]);
2085   }
2086
2087   LayerOwner::DestroyLayer();
2088
2089   if (new_parent)
2090     ReorderLayers();
2091
2092   UpdateChildLayerBounds(CalculateOffsetToAncestorWithLayer(NULL));
2093
2094   SchedulePaint();
2095
2096   Widget* widget = GetWidget();
2097   if (widget)
2098     widget->UpdateRootLayers();
2099 }
2100
2101 // Input -----------------------------------------------------------------------
2102
2103 bool View::ProcessMousePressed(const ui::MouseEvent& event) {
2104   int drag_operations =
2105       (enabled_ && event.IsOnlyLeftMouseButton() &&
2106        HitTestPoint(event.location())) ?
2107        GetDragOperations(event.location()) : 0;
2108   ContextMenuController* context_menu_controller = event.IsRightMouseButton() ?
2109       context_menu_controller_ : 0;
2110   View::DragInfo* drag_info = GetDragInfo();
2111
2112   // TODO(sky): for debugging 360238.
2113   int storage_id = 0;
2114   if (event.IsOnlyRightMouseButton() && context_menu_controller &&
2115       kContextMenuOnMousePress && HitTestPoint(event.location())) {
2116     ViewStorage* view_storage = ViewStorage::GetInstance();
2117     storage_id = view_storage->CreateStorageID();
2118     view_storage->StoreView(storage_id, this);
2119   }
2120
2121   const bool enabled = enabled_;
2122   const bool result = OnMousePressed(event);
2123
2124   if (!enabled)
2125     return result;
2126
2127   if (event.IsOnlyRightMouseButton() && context_menu_controller &&
2128       kContextMenuOnMousePress) {
2129     // Assume that if there is a context menu controller we won't be deleted
2130     // from mouse pressed.
2131     gfx::Point location(event.location());
2132     if (HitTestPoint(location)) {
2133       if (storage_id != 0)
2134         CHECK_EQ(this, ViewStorage::GetInstance()->RetrieveView(storage_id));
2135       ConvertPointToScreen(this, &location);
2136       ShowContextMenu(location, ui::MENU_SOURCE_MOUSE);
2137       return true;
2138     }
2139   }
2140
2141   // WARNING: we may have been deleted, don't use any View variables.
2142   if (drag_operations != ui::DragDropTypes::DRAG_NONE) {
2143     drag_info->PossibleDrag(event.location());
2144     return true;
2145   }
2146   return !!context_menu_controller || result;
2147 }
2148
2149 bool View::ProcessMouseDragged(const ui::MouseEvent& event) {
2150   // Copy the field, that way if we're deleted after drag and drop no harm is
2151   // done.
2152   ContextMenuController* context_menu_controller = context_menu_controller_;
2153   const bool possible_drag = GetDragInfo()->possible_drag;
2154   if (possible_drag &&
2155       ExceededDragThreshold(GetDragInfo()->start_pt - event.location()) &&
2156       (!drag_controller_ ||
2157        drag_controller_->CanStartDragForView(
2158            this, GetDragInfo()->start_pt, event.location()))) {
2159     DoDrag(event, GetDragInfo()->start_pt,
2160            ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
2161   } else {
2162     if (OnMouseDragged(event))
2163       return true;
2164     // Fall through to return value based on context menu controller.
2165   }
2166   // WARNING: we may have been deleted.
2167   return (context_menu_controller != NULL) || possible_drag;
2168 }
2169
2170 void View::ProcessMouseReleased(const ui::MouseEvent& event) {
2171   if (!kContextMenuOnMousePress && context_menu_controller_ &&
2172       event.IsOnlyRightMouseButton()) {
2173     // Assume that if there is a context menu controller we won't be deleted
2174     // from mouse released.
2175     gfx::Point location(event.location());
2176     OnMouseReleased(event);
2177     if (HitTestPoint(location)) {
2178       ConvertPointToScreen(this, &location);
2179       ShowContextMenu(location, ui::MENU_SOURCE_MOUSE);
2180     }
2181   } else {
2182     OnMouseReleased(event);
2183   }
2184   // WARNING: we may have been deleted.
2185 }
2186
2187 // Accelerators ----------------------------------------------------------------
2188
2189 void View::RegisterPendingAccelerators() {
2190   if (!accelerators_.get() ||
2191       registered_accelerator_count_ == accelerators_->size()) {
2192     // No accelerators are waiting for registration.
2193     return;
2194   }
2195
2196   if (!GetWidget()) {
2197     // The view is not yet attached to a widget, defer registration until then.
2198     return;
2199   }
2200
2201   accelerator_focus_manager_ = GetFocusManager();
2202   if (!accelerator_focus_manager_) {
2203     // Some crash reports seem to show that we may get cases where we have no
2204     // focus manager (see bug #1291225).  This should never be the case, just
2205     // making sure we don't crash.
2206     NOTREACHED();
2207     return;
2208   }
2209   for (std::vector<ui::Accelerator>::const_iterator i(
2210            accelerators_->begin() + registered_accelerator_count_);
2211        i != accelerators_->end(); ++i) {
2212     accelerator_focus_manager_->RegisterAccelerator(
2213         *i, ui::AcceleratorManager::kNormalPriority, this);
2214   }
2215   registered_accelerator_count_ = accelerators_->size();
2216 }
2217
2218 void View::UnregisterAccelerators(bool leave_data_intact) {
2219   if (!accelerators_.get())
2220     return;
2221
2222   if (GetWidget()) {
2223     if (accelerator_focus_manager_) {
2224       accelerator_focus_manager_->UnregisterAccelerators(this);
2225       accelerator_focus_manager_ = NULL;
2226     }
2227     if (!leave_data_intact) {
2228       accelerators_->clear();
2229       accelerators_.reset();
2230     }
2231     registered_accelerator_count_ = 0;
2232   }
2233 }
2234
2235 // Focus -----------------------------------------------------------------------
2236
2237 void View::InitFocusSiblings(View* v, int index) {
2238   int count = child_count();
2239
2240   if (count == 0) {
2241     v->next_focusable_view_ = NULL;
2242     v->previous_focusable_view_ = NULL;
2243   } else {
2244     if (index == count) {
2245       // We are inserting at the end, but the end of the child list may not be
2246       // the last focusable element. Let's try to find an element with no next
2247       // focusable element to link to.
2248       View* last_focusable_view = NULL;
2249       for (Views::iterator i(children_.begin()); i != children_.end(); ++i) {
2250           if (!(*i)->next_focusable_view_) {
2251             last_focusable_view = *i;
2252             break;
2253           }
2254       }
2255       if (last_focusable_view == NULL) {
2256         // Hum... there is a cycle in the focus list. Let's just insert ourself
2257         // after the last child.
2258         View* prev = children_[index - 1];
2259         v->previous_focusable_view_ = prev;
2260         v->next_focusable_view_ = prev->next_focusable_view_;
2261         prev->next_focusable_view_->previous_focusable_view_ = v;
2262         prev->next_focusable_view_ = v;
2263       } else {
2264         last_focusable_view->next_focusable_view_ = v;
2265         v->next_focusable_view_ = NULL;
2266         v->previous_focusable_view_ = last_focusable_view;
2267       }
2268     } else {
2269       View* prev = children_[index]->GetPreviousFocusableView();
2270       v->previous_focusable_view_ = prev;
2271       v->next_focusable_view_ = children_[index];
2272       if (prev)
2273         prev->next_focusable_view_ = v;
2274       children_[index]->previous_focusable_view_ = v;
2275     }
2276   }
2277 }
2278
2279 void View::AdvanceFocusIfNecessary() {
2280   // Focus should only be advanced if this is the focused view and has become
2281   // unfocusable. If the view is still focusable or is not focused, we can
2282   // return early avoiding furthur unnecessary checks. Focusability check is
2283   // performed first as it tends to be faster.
2284   if (IsAccessibilityFocusable() || !HasFocus())
2285     return;
2286
2287   FocusManager* focus_manager = GetFocusManager();
2288   if (focus_manager)
2289     focus_manager->AdvanceFocusIfNecessary();
2290 }
2291
2292 // System events ---------------------------------------------------------------
2293
2294 void View::PropagateThemeChanged() {
2295   for (int i = child_count() - 1; i >= 0; --i)
2296     child_at(i)->PropagateThemeChanged();
2297   OnThemeChanged();
2298 }
2299
2300 void View::PropagateLocaleChanged() {
2301   for (int i = child_count() - 1; i >= 0; --i)
2302     child_at(i)->PropagateLocaleChanged();
2303   OnLocaleChanged();
2304 }
2305
2306 void View::PropagateDeviceScaleFactorChanged(float device_scale_factor) {
2307   for (int i = child_count() - 1; i >= 0; --i)
2308     child_at(i)->PropagateDeviceScaleFactorChanged(device_scale_factor);
2309
2310   // If the view is drawing to the layer, OnDeviceScaleFactorChanged() is called
2311   // through LayerDelegate callback.
2312   if (!layer())
2313     OnDeviceScaleFactorChanged(device_scale_factor);
2314 }
2315
2316 // Tooltips --------------------------------------------------------------------
2317
2318 void View::UpdateTooltip() {
2319   Widget* widget = GetWidget();
2320   // TODO(beng): The TooltipManager NULL check can be removed when we
2321   //             consolidate Init() methods and make views_unittests Init() all
2322   //             Widgets that it uses.
2323   if (widget && widget->GetTooltipManager())
2324     widget->GetTooltipManager()->UpdateTooltip();
2325 }
2326
2327 // Drag and drop ---------------------------------------------------------------
2328
2329 bool View::DoDrag(const ui::LocatedEvent& event,
2330                   const gfx::Point& press_pt,
2331                   ui::DragDropTypes::DragEventSource source) {
2332   int drag_operations = GetDragOperations(press_pt);
2333   if (drag_operations == ui::DragDropTypes::DRAG_NONE)
2334     return false;
2335
2336   Widget* widget = GetWidget();
2337   // We should only start a drag from an event, implying we have a widget.
2338   DCHECK(widget);
2339
2340   // Don't attempt to start a drag while in the process of dragging. This is
2341   // especially important on X where we can get multiple mouse move events when
2342   // we start the drag.
2343   if (widget->dragged_view())
2344     return false;
2345
2346   OSExchangeData data;
2347   WriteDragData(press_pt, &data);
2348
2349   // Message the RootView to do the drag and drop. That way if we're removed
2350   // the RootView can detect it and avoid calling us back.
2351   gfx::Point widget_location(event.location());
2352   ConvertPointToWidget(this, &widget_location);
2353   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
2354   // WARNING: we may have been deleted.
2355   return true;
2356 }
2357
2358 }  // namespace views