Animated Rotation

views/view.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/view.h"
 
 #include <algorithm>
 
+#include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/accessibility/accessibility_types.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
@@ skipping 89 matching lines @@
       clip_y_(0.0),
       needs_layout_(true),
       flip_canvas_on_paint_for_rtl_ui_(false),
       accelerator_registration_delayed_(false),
       accelerator_focus_manager_(NULL),
       registered_accelerator_count_(0),
       next_focusable_view_(NULL),
       previous_focusable_view_(NULL),
       focusable_(false),
       accessibility_focusable_(false),
+      painting_enabled_(true),
       context_menu_controller_(NULL),
       drag_controller_(NULL) {
 }
 
 View::~View() {
   if (parent_)
     parent_->RemoveChildView(this);
 
   for (Views::const_iterator i(children_.begin()); i != children_.end(); ++i) {
     (*i)->parent_ = NULL;
@@ skipping 285 matching lines @@
 }
 
 bool View::IsEnabled() const {
   return enabled_;
 }
 
 void View::OnEnabledChanged() {
   SchedulePaint();
 }
 
+void View::SetPaintingEnabled(bool enabled) {
+  painting_enabled_ = enabled;
+}
+
+bool View::IsPaintingEnabled() const {
+  return painting_enabled_;
+}
+
 // Transformations -------------------------------------------------------------
 
 const ui::Transform& View::GetTransform() const {
   static const ui::Transform* no_op = new ui::Transform;
   return transform() ? *transform() : *no_op;
 }
 
 void View::SetTransform(const ui::Transform& transform) {
   if (!transform.HasChange()) {
     if (!layer_helper_.get() || !this->transform())
       return;
     layer_helper_->SetTransform(transform);
 
     if (!ShouldPaintToLayer())
       DestroyLayerAndReparent();
     else if (layer())
       layer_helper_->property_setter()->SetTransform(layer(), transform);
 
     SchedulePaint();
   } else {
-    // Make sure if the view didn't have its own texture and was painting onto
-    // something else, that gets refreshed too.
-    if (!ShouldPaintToLayer())
-      MarkLayerDirty();
-
     if (!layer_helper_.get())
       layer_helper_.reset(new internal::LayerHelper());
     layer_helper_->SetTransform(transform);
     if (!layer()) {
       CreateLayer();
       SchedulePaint();
     } else {
       layer_helper_->property_setter()->SetTransform(layer(), transform);
-      // We have a layer. When the transform changes and the layer is up to
-      // date we don't want to SchedulePaint as it'll trigger painting to the
-      // layer. Instead we tell the Widget to paint, which makes the
-      // compositor draw using the existing layer.
-      // We schedule paint the complete bounds as compositor generally don't
-      // support partial painting.
-      Widget* widget = GetWidget();
-      if (widget)
-        widget->SchedulePaintInRect(widget->GetRootView()->bounds());
+      ScheduleComposite();
     }
   }
 }
 
 void View::SetPaintToLayer(bool value) {
   bool paint_to_layer = layer_helper_.get() && layer_helper_->paint_to_layer();
   if (value == paint_to_layer)
     return;
 
   if (value) {
@@ skipping 45 matching lines @@
   return base::i18n::IsRTL() ? width() - x : x;
 }
 
 int View::GetMirroredXWithWidthInView(int x, int w) const {
   return base::i18n::IsRTL() ? width() - x - w : x;
 }
 
 // Layout ----------------------------------------------------------------------
 
 void View::Layout() {
+  TRACE_EVENT0("View", "Layout");
   needs_layout_ = false;
 
   // If we have a layout manager, let it handle the layout for us.
   if (layout_manager_.get())
     layout_manager_->Layout(this);
 
   // Make sure to propagate the Layout() call to any children that haven't
   // received it yet through the layout manager and need to be laid out. This
   // is needed for the case when the child requires a layout but its bounds
   // weren't changed by the layout manager. If there is no layout manager, we
@@ skipping 148 matching lines @@
 }
 
 void View::SchedulePaintInRect(const gfx::Rect& rect) {
   if (!IsVisible())
     return;
 
   MarkLayerDirty();
   SchedulePaintInternal(rect);
 }
 
+void View::ScheduleComposite() {
+  ScheduleCompositeInRect(GetLocalBounds());
+}
+
+void View::ScheduleCompositeInRect(const gfx::Rect& rect) {
+   if (!IsVisible())
+     return;
+
+  SchedulePaintInternal(rect);
+}
+
 void View::Paint(gfx::Canvas* canvas) {
-  if (!IsVisible())
+  TRACE_EVENT0("View", "Paint");
+  if (!IsVisible() || !IsPaintingEnabled())
     return;
 
   ScopedCanvas scoped_canvas(NULL);
   scoped_ptr<gfx::Canvas> layer_canvas;
   gfx::Rect layer_rect;
 
   if (layer()) {
     gfx::Rect dirty_rect;
     if (!layer_helper_->clip_rect().IsEmpty()) {
       dirty_rect = layer_helper_->clip_rect();
@@ skipping 454 matching lines @@
 }
 
 void View::OnPaintFocusBorder(gfx::Canvas* canvas) {
   if ((IsFocusable() || IsAccessibilityFocusableInRootView()) && HasFocus())
     canvas->DrawFocusRect(0, 0, width(), height());
 }
 
 // Accelerated Painting --------------------------------------------------------
 
 void View::PaintComposite() {
+  TRACE_EVENT0("View", "PaintComposite");
   if (!IsVisible())
     return;
 
   if (layer()) {
     OnWillCompositeLayer();
     layer()->Draw();
   }
 
   for (int i = 0, count = child_count(); i < count; ++i)
     GetChildViewAt(i)->PaintComposite();
@@ skipping 861 matching lines @@
     result.append(GetChildViewAt(i)->PrintViewGraph(false));
 
   if (first)
     result.append("}\n");
 
   return result;
 }
 #endif
 
 }  // namespace views