readability review for luken

ui/views/view.cc

 // Copyright (c) 2012 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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 764 matching lines @@
 
     // Non-empty clip, translate the graphics such that 0,0 corresponds to where
     // this view is located (related to its parent).
     canvas->Translate(GetMirroredPosition().OffsetFromOrigin());
     canvas->Transform(GetTransform());
 
     // If we are a paint root, we need to construct our own CullSet object for
     // propagation to our children.
     if (IsPaintRoot()) {
       if (!bounds_tree_)
-        bounds_tree_.reset(new gfx::RTree(2, 5));
+        bounds_tree_.reset(new BoundsTree(2, 5));
 
       // Recompute our bounds tree as needed.
       UpdateRootBounds(bounds_tree_.get(), gfx::Vector2d());
 
       // Grab the clip rect from the supplied canvas to use as the query rect.
       gfx::Rect canvas_bounds;
       if (!canvas->GetClipBounds(&canvas_bounds)) {
         NOTREACHED() << "Failed to get clip bounds from the canvas!";
         return;
       }
 
       // Now query our bounds_tree_ for a set of damaged views that intersect
       // our canvas bounds.
       scoped_ptr<base::hash_set<intptr_t> > damaged_views(
           new base::hash_set<intptr_t>());
-      bounds_tree_->Query(canvas_bounds, damaged_views.get());
+      bounds_tree_->AppendIntersectingRecords(
+          canvas_bounds, damaged_views.get());
       // Construct a CullSet to wrap the damaged views set, it will delete it
       // for us on scope exit.
       CullSet paint_root_cull_set(damaged_views.Pass());
       // Paint all descendents using our new cull set.
       PaintCommon(canvas, paint_root_cull_set);
     } else {
       // Not a paint root, so we can proceed as normal.
       PaintCommon(canvas, cull_set);
     }
   }
@@ skipping 1051 matching lines @@
 
     if (GetWidget()) {
       UnregisterChildrenForVisibleBoundsNotification(view);
       if (view->visible())
         view->SchedulePaint();
       GetWidget()->NotifyWillRemoveView(view);
     }
 
     // Remove the bounds of this child and any of its descendants from our
     // paint root bounds tree.
-    gfx::RTree* bounds_tree = GetBoundsTreeFromPaintRoot();
+    BoundsTree* bounds_tree = GetBoundsTreeFromPaintRoot();
     if (bounds_tree)
       view->RemoveRootBounds(bounds_tree);
 
     view->PropagateRemoveNotifications(this, new_parent);
     view->parent_ = NULL;
     view->UpdateLayerVisibility();
 
     if (delete_removed_view && !view->owned_by_client_)
       view_to_be_deleted.reset(view);
 
@@ skipping 190 matching lines @@
     // Inform our children that their root bounds are dirty, as their relative
     // coordinates in paint root space have changed since ours have changed.
     for (Views::const_iterator i(children_.begin()); i != children_.end();
          ++i) {
       if (!(*i)->IsPaintRoot())
         (*i)->SetRootBoundsDirty(origin_changed);
     }
   }
 }
 
-void View::UpdateRootBounds(gfx::RTree* tree, const gfx::Vector2d& offset) {
+void View::UpdateRootBounds(BoundsTree* tree, const gfx::Vector2d& offset) {
   // No need to recompute bounds if we haven't flagged ours as dirty.
   TRACE_EVENT1("views", "View::UpdateRootBounds", "class", GetClassName());
 
   // Add our own offset to the provided offset, for our own bounds update and
   // for propagation to our children if needed.
   gfx::Vector2d view_offset = offset + GetMirroredBounds().OffsetFromOrigin();
 
   // If our bounds have changed we must re-insert our new bounds to the tree.
   if (root_bounds_dirty_) {
     root_bounds_dirty_ = false;
     gfx::Rect bounds(
         view_offset.x(), view_offset.y(), bounds_.width(), bounds_.height());
     tree->Insert(bounds, reinterpret_cast<intptr_t>(this));
   }
 
   // Update our children's bounds if needed.
   for (Views::const_iterator i(children_.begin()); i != children_.end(); ++i) {
     // We don't descend in to layer views for bounds recomputation, as they
     // manage their own RTree as paint roots.
     if (!(*i)->IsPaintRoot())
       (*i)->UpdateRootBounds(tree, view_offset);
   }
 }
 
-void View::RemoveRootBounds(gfx::RTree* tree) {
+void View::RemoveRootBounds(BoundsTree* tree) {
   tree->Remove(reinterpret_cast<intptr_t>(this));
 
   root_bounds_dirty_ = true;
 
   for (Views::const_iterator i(children_.begin()); i != children_.end(); ++i) {
     if (!(*i)->IsPaintRoot())
       (*i)->RemoveRootBounds(tree);
   }
 }
 
-gfx::RTree* View::GetBoundsTreeFromPaintRoot() {
-  gfx::RTree* bounds_tree = bounds_tree_.get();
+View::BoundsTree* View::GetBoundsTreeFromPaintRoot() {
+  BoundsTree* bounds_tree = bounds_tree_.get();
   View* paint_root = this;
   while (!bounds_tree && !paint_root->IsPaintRoot()) {
     // Assumption is that if IsPaintRoot() is false then parent_ is valid.
     DCHECK(paint_root);
     paint_root = paint_root->parent_;
     bounds_tree = paint_root->bounds_tree_.get();
   }
 
   return bounds_tree;
 }
@@ skipping 368 matching lines @@
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views