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