Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/trees/layer_sorter.cc

 // Copyright 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 "cc/trees/layer_sorter.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 #include <vector>
@@ skipping 72 matching lines @@
 // if the layers are found to be intesecting (some features are in front and
 // some are behind).
 LayerSorter::ABCompareResult LayerSorter::CheckOverlap(LayerShape* a,
                                                        LayerShape* b,
                                                        float z_threshold,
                                                        float* weight) {
   *weight = 0.f;
 
   // Early out if the projected bounds don't overlap.
   if (!a->projected_bounds.Intersects(b->projected_bounds))
-    return NONE;
+    return None;
 
   gfx::PointF aPoints[4] = { a->projected_quad.p1(),
                              a->projected_quad.p2(),
                              a->projected_quad.p3(),
                              a->projected_quad.p4() };
   gfx::PointF bPoints[4] = { b->projected_quad.p1(),
                              b->projected_quad.p2(),
                              b->projected_quad.p3(),
                              b->projected_quad.p4() };
 
@@ skipping 12 matching lines @@
   // edges.
   gfx::PointF r;
   for (int ea = 0; ea < 4; ++ea)
     for (int eb = 0; eb < 4; ++eb)
       if (EdgeEdgeTest(aPoints[ea], aPoints[(ea + 1) % 4],
                        bPoints[eb], bPoints[(eb + 1) % 4],
                        &r))
         overlap_points.push_back(r);
 
   if (overlap_points.empty())
-    return NONE;
+    return None;
 
   // Check the corresponding layer depth value for all overlap points to
   // determine which layer is in front.
   float max_positive = 0.f;
   float max_negative = 0.f;
 
   // This flag tracks the existance of a numerically accurate seperation
   // between two layers.  If there is no accurate seperation, the layers
   // cannot be effectively sorted.
   bool accurate = false;
@@ skipping 13 matching lines @@
 
     float diff = za - zb;
     if (diff > max_positive)
       max_positive = diff;
     if (diff < max_negative)
       max_negative = diff;
   }
 
   // If we can't tell which should come first, we use document order.
   if (!accurate)
-    return A_BEFORE_B;
+    return ABeforeB;
 
   float max_diff =
       std::abs(max_positive) > std::abs(max_negative) ?
           max_positive : max_negative;
 
   // If the results are inconsistent (and the z difference substantial to rule
   // out numerical errors) then the layers are intersecting. We will still
   // return an order based on the maximum depth difference but with an edge
   // weight of zero these layers will get priority if a graph cycle is present
   // and needs to be broken.
   if (max_positive > z_threshold && max_negative < -z_threshold)
     *weight = 0.f;
   else
     *weight = std::abs(max_diff);
 
   // Maintain relative order if the layers have the same depth at all
   // intersection points.
   if (max_diff <= 0.f)
-    return A_BEFORE_B;
+    return ABeforeB;
 
-  return B_BEFORE_A;
+  return BBeforeA;
 }
 
 LayerShape::LayerShape() {}
 
 LayerShape::LayerShape(float width,
                        float height,
                        const gfx::Transform& draw_transform) {
   gfx::QuadF layer_quad(gfx::RectF(0.f, 0.f, width, height));
 
   // Compute the projection of the layer quad onto the z = 0 plane.
@@ skipping 121 matching lines @@
       GraphNode& node_b = nodes_[nb];
       if (!node_b.layer->DrawsContent() && !node_b.layer->render_surface())
         continue;
       float weight = 0.f;
       ABCompareResult overlap_result = CheckOverlap(&node_a.shape,
                                                     &node_b.shape,
                                                     z_threshold,
                                                     &weight);
       GraphNode* start_node = NULL;
       GraphNode* end_node = NULL;
-      if (overlap_result == A_BEFORE_B) {
+      if (overlap_result == ABeforeB) {
         start_node = &node_a;
         end_node = &node_b;
-      } else if (overlap_result == B_BEFORE_A) {
+      } else if (overlap_result == BBeforeA) {
         start_node = &node_b;
         end_node = &node_a;
       }
 
       if (start_node) {
         DVLOG(2) << start_node->layer->id() << " -> " << end_node->layer->id();
         edges_.push_back(GraphEdge(start_node, end_node, weight));
       }
     }
   }
@@ skipping 124 matching lines @@
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
 
   nodes_.clear();
   edges_.clear();
   active_edges_.clear();
 }
 
 }  // namespace cc