Remove COMPOSITOR_2 flag, old compositor code.

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/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 88 matching lines @@
       id_(0),
       group_(-1),
       parent_(NULL),
       is_visible_(true),
       enabled_(true),
       registered_for_visible_bounds_notification_(false),
       clip_x_(0.0),
       clip_y_(0.0),
       needs_layout_(true),
       flip_canvas_on_paint_for_rtl_ui_(false),
-#if !defined(COMPOSITOR_2)
-      texture_id_(0),  // TODO(sadrul): 0 can be a valid texture id.
-#endif
       texture_needs_updating_(true),
       paint_to_texture_(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),
       context_menu_controller_(NULL),
@@ skipping 48 matching lines @@
   for (View* p = this; p; p = p->parent())
     p->ViewHierarchyChangedImpl(false, true, this, view);
 
   view->PropagateAddNotifications(this, view);
   UpdateTooltip();
   if (GetWidget())
     RegisterChildrenForVisibleBoundsNotification(view);
 
   if (layout_manager_.get())
     layout_manager_->ViewAdded(this, view);
-#if defined(COMPOSITOR_2)
+
   view->MarkTextureDirty();
-#endif
 }
 
 void View::RemoveChildView(View* view) {
   DoRemoveChildView(view, true, true, false);
 }
 
 void View::RemoveAllChildViews(bool delete_children) {
   while (!children_.empty())
     DoRemoveChildView(children_.front(), false, false, delete_children);
   UpdateTooltip();
@@ skipping 202 matching lines @@
   if (transform_.get())
     return *transform_.get();
   return *no_op;
 }
 
 void View::SetTransform(const ui::Transform& transform) {
   if (!transform.HasChange()) {
     if (!transform_.get())
       return;
     transform_.reset(NULL);
-#if !defined(COMPOSITOR_2)
-    canvas_.reset();
-#else
+
     if (!paint_to_texture_)
       texture_.reset();
-#endif
+
     SchedulePaint();
   } else {
     transform_.reset(new ui::Transform(transform));
-#if defined(COMPOSITOR_2)
     if (!texture_.get()) {
       // We don't yet have a texture. SchedulePaint so one is created.
       SchedulePaint();
     } else {
       // We have a texture. When the transform changes and the texture is up to
       // date we don't want to SchedulePaint as it'll trigger painting to the
       // texture. Instead we tell the Widget to paint, which makes the
       // compositor draw using the existing texture.
       // We schedule paint the complete bounds as compositor generally don't
       // support partial painting.
       Widget* widget = GetWidget();
       if (widget)
         widget->SchedulePaintInRect(widget->GetRootView()->bounds());
     }
-#endif
   }
 }
 
 void View::SetPaintToTexture(bool value) {
-#if defined(COMPOSITOR_2)
   if (value == paint_to_texture_)
     return;
 
   paint_to_texture_ = value;
   if (!ShouldPaintToTexture())
     texture_.reset();
-#endif
 }
 
 // RTL positioning -------------------------------------------------------------
 
 gfx::Rect View::GetMirroredBounds() const {
   gfx::Rect bounds(bounds_);
   bounds.set_x(GetMirroredX());
   return bounds;
 }
 
@@ skipping 171 matching lines @@
 // Painting --------------------------------------------------------------------
 
 void View::SchedulePaint() {
   SchedulePaintInRect(GetLocalBounds());
 }
 
 void View::SchedulePaintInRect(const gfx::Rect& rect) {
   if (!IsVisible())
     return;
 
-#if defined(COMPOSITOR_2)
   MarkTextureDirty();
   SchedulePaintInternal(rect);
-#else
-  if (parent_) {
-    // Translate the requested paint rect to the parent's coordinate system
-    // then pass this notification up to the parent.
-    gfx::Rect paint_rect = ConvertRectToParent(rect);
-    paint_rect.Offset(GetMirroredPosition());
-    parent_->SchedulePaintInRect(paint_rect);
-  }
-#endif
 }
 
 void View::Paint(gfx::Canvas* canvas) {
   if (!IsVisible())
     return;
 
   ScopedCanvas scoped_canvas(NULL);
   scoped_ptr<gfx::Canvas> texture_canvas;
   gfx::Rect texture_rect;
 
-#if !defined(COMPOSITOR_2)
-  if (use_acceleration_when_possible &&
-      transform_.get() && transform_->HasChange()) {
-    // This view has a transformation. So this maintains its own canvas.
-    if (!canvas_.get())
-      canvas_.reset(gfx::Canvas::CreateCanvas(width(), height(), false));
-#else
   if (ShouldPaintToTexture()) {
     gfx::Rect dirty_rect;
     if (!texture_clip_rect_.IsEmpty()) {
       dirty_rect = texture_clip_rect_;
     } else {
       // TODO: clip against dirty rect of canvas (if canvas is non-null).
       dirty_rect = gfx::Rect(0, 0, width(), height());
     }
     if (dirty_rect.IsEmpty())
       return;
@@ skipping 10 matching lines @@
       return;
     }
 
     texture_canvas.reset(gfx::Canvas::CreateCanvas(dirty_rect.width(),
         dirty_rect.height(), false));
     texture_canvas->AsCanvasSkia()->drawColor(
         SK_ColorBLACK, SkXfermode::kClear_Mode);
     texture_canvas->TranslateInt(-dirty_rect.x(), -dirty_rect.y());
     canvas = texture_canvas.get();
     texture_rect = dirty_rect;
-#endif
   } else {
     // We're going to modify the canvas, save its state first.
     scoped_canvas.SetCanvas(canvas);
 
     // Paint this View and its children, setting the clip rect to the bounds
     // of this View and translating the origin to the local bounds' top left
     // point.
     //
     // Note that the X (or left) position we pass to ClipRectInt takes into
     // consideration whether or not the view uses a right-to-left layout so that
@@ skipping 22 matching lines @@
     if (FlipCanvasOnPaintForRTLUI()) {
       canvas->TranslateInt(width(), 0);
       canvas->ScaleInt(-1, 1);
     }
 
     OnPaint(canvas);
   }
 
   PaintChildren(canvas);
 
-#if !defined(COMPOSITOR_2)
-  if (canvas == canvas_.get()) {
-    texture_id_ = canvas->GetTextureID();
-
-    // TODO(sadrul): Make sure the Widget's compositor tree updates itself?
-  }
-#else
   if (texture_canvas.get()) {
     texture_->SetBitmap(
         texture_canvas->AsCanvasSkia()->getDevice()->accessBitmap(false),
         texture_rect.origin(),
         size());
     texture_needs_updating_ = false;
   }
-#endif
 }
 
 ThemeProvider* View::GetThemeProvider() const {
   const Widget* widget = GetWidget();
   return widget ? widget->GetThemeProvider() : NULL;
 }
 
 // Accelerated Painting --------------------------------------------------------
 
 // static
@@ skipping 388 matching lines @@
     border_->Paint(*this, canvas);
 }
 
 void View::OnPaintFocusBorder(gfx::Canvas* canvas) {
   if ((IsFocusable() || IsAccessibilityFocusableInRootView()) && HasFocus())
     canvas->DrawFocusRect(0, 0, width(), height());
 }
 
 // Accelerated Painting --------------------------------------------------------
 
-#if !defined(COMPOSITOR_2)
-void View::PaintComposite(ui::Compositor* compositor) {
-  compositor->SaveTransform();
-
-  // TODO(sad): Push a transform matrix for the offset and bounds of the view?
-  if (texture_id_)
-    compositor->DrawTextureWithTransform(texture_id_, GetTransform());
-
-  for (int i = 0, count = child_count(); i < count; ++i) {
-    View* child = GetChildViewAt(i);
-    child->PaintComposite(compositor);
-  }
-
-  compositor->RestoreTransform();
-}
-#else
 void View::PaintComposite() {
   if (!IsVisible())
     return;
 
   if (texture_.get()) {
     OnWillCompositeTexture();
     ui::Transform transform;
     GetTransformRelativeTo(NULL, &transform);
     texture_->Draw(transform);
   }
@@ skipping 39 matching lines @@
         child_dirty_rect.Offset(-child_view->x(), -child_view->y());
         GetChildViewAt(i)->PaintToTexture(child_dirty_rect);
       }
     }
   }
 }
 
 void View::OnWillCompositeTexture() {
 }
 
-#endif
-
 bool View::ShouldPaintToTexture() const {
   return use_acceleration_when_possible &&
       (paint_to_texture_ || (transform_.get() && transform_->HasChange())) &&
        GetCompositor();
 }
 
 const ui::Compositor* View::GetCompositor() const {
   return parent_ ? parent_->GetCompositor() : NULL;
 }
 
@@ skipping 195 matching lines @@
 
 void View::VisibilityChangedImpl(View* starting_from, bool is_visible) {
   if (is_visible)
     RegisterPendingAccelerators();
   else
     UnregisterAccelerators(true);
   VisibilityChanged(starting_from, is_visible);
 }
 
 void View::BoundsChanged(const gfx::Rect& previous_bounds) {
-#if !defined(COMPOSITOR_2)
-  if (canvas_.get())
-    canvas_.reset(gfx::Canvas::CreateCanvas(width(), height(), false));
-#endif
-
   if (IsVisible()) {
     if (parent_) {
       // Paint the old bounds.
       if (base::i18n::IsRTL()) {
         gfx::Rect paint_rect = previous_bounds;
         paint_rect.set_x(parent()->GetMirroredXForRect(paint_rect));
         parent_->SchedulePaintInRect(paint_rect);
       } else {
         parent_->SchedulePaintInRect(previous_bounds);
       }
@@ skipping 144 matching lines @@
 bool View::ConvertPointFromAncestor(const View* ancestor,
                                     gfx::Point* point) const {
   ui::Transform trans;
   bool result = GetTransformRelativeTo(ancestor, &trans);
   trans.TransformPointReverse(point);
   return result;
 }
 
 // Accelerated painting --------------------------------------------------------
 
-#if defined(COMPOSITOR_2)
 void View::MarkTextureDirty() {
   View* owner = this;
   while (!((owner->transform_.get() && owner->transform_->HasChange()) ||
            owner->paint_to_texture_) && owner->parent())
     owner = owner->parent();
   owner->texture_needs_updating_ = true;
 }
-#endif
 
 void View::ResetTexture() {
-#if defined(COMPOSITOR_2)
   texture_.reset();
   for (int i = child_count() - 1; i >= 0; --i)
     GetChildViewAt(i)->ResetTexture();
-#endif
 }
 
 // Input -----------------------------------------------------------------------
 
 bool View::ProcessMousePressed(const MouseEvent& event, DragInfo* drag_info) {
   const bool enabled = IsEnabled();
   int drag_operations =
       (enabled && event.IsOnlyLeftMouseButton() && HitTest(event.location())) ?
       GetDragOperations(event.location()) : 0;
   ContextMenuController* context_menu_controller = event.IsRightMouseButton() ?
@@ skipping 224 matching lines @@
 
   // Information about current node.
   snprintf(p, kMaxPointerStringLength, "%p", this);
   result.append("  N");
   result.append(p+2);
   result.append(" [label=\"");
   result.append(GetClassName().substr(baseNameIndex).c_str());
   result.append("\"");
   if (!parent())
     result.append(", shape=box");
-#if defined(COMPOSITOR_2)
   if (texture_.get())
-#else
-  if (canvas_.get())
-#endif
     result.append(", color=green");
   result.append("]\n");
 
   // Link to parent.
   if (parent()) {
     char pp[kMaxPointerStringLength];
 
     snprintf(pp, kMaxPointerStringLength, "%p", parent());
     result.append("  N");
     result.append(pp+2);
     result.append(" -> N");
     result.append(p+2);
     result.append("\n");
   }
 
   // Children.
   for (int i = 0, count = child_count(); i < count; ++i)
     result.append(GetChildViewAt(i)->PrintViewGraph(false));
 
   if (first)
     result.append("}\n");
 
   return result;
 }
 #endif
 
 }  // namespace views