Remove WebCore::IntRect usage from compositor, except within Region.

cc/stubs/Region.h

 // 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.
 
 #ifndef CC_STUBS_REGION_H_
 #define CC_STUBS_REGION_H_
 
-#include "IntRect.h"
 #if INSIDE_WEBKIT_BUILD
 #include "Source/WebCore/platform/graphics/Region.h"
 #else
 #include "third_party/WebKit/Source/WebCore/platform/graphics/Region.h"
 #endif
+#include "base/logging.h"
 #include "ui/gfx/rect.h"
 
 namespace cc {
 
 class Region : public WebCore::Region {
 public:
     Region() { }
 
-    Region(const IntRect& rect)
-        : WebCore::Region(rect)
-    {
-    }
-
-    Region(const WebCore::IntRect& rect)
-        : WebCore::Region(rect)
-    {
-    }
-
     Region(const WebCore::Region& region)
         : WebCore::Region(region)
     {
     }
 
     Region(const gfx::Rect& rect)
         : WebCore::Region(WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height()))
     {
     }
 
     bool IsEmpty() const { return isEmpty(); }
 
-    bool Contains(const gfx::Point& point) const { return contains(cc::IntPoint(point)); }
-    bool Contains(const gfx::Rect& rect) const { return contains(cc::IntRect(rect)); }
-    void Subtract(const gfx::Rect& rect) { subtract(cc::IntRect(rect)); }
+    bool Contains(const gfx::Point& point) const { return contains(WebCore::IntPoint(point.x(), point.y())); }
+    bool Contains(const gfx::Rect& rect) const { return contains(WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height())); }
+    void Subtract(const gfx::Rect& rect) { subtract(WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height())); }
     void Subtract(const Region& region) { subtract(region); }
-    void Union(const gfx::Rect& rect) { unite(cc::IntRect(rect)); }
+    void Union(const gfx::Rect& rect) { unite(WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height())); }
     void Union(const Region& region) { unite(region); }
-    void Intersect(const gfx::Rect& rect) { intersect(cc::IntRect(rect)); }
+    void Intersect(const gfx::Rect& rect) { intersect(WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height())); }
     void Intersect(const Region& region) { intersect(region); }
 
-    gfx::Rect bounds() const { return cc::IntRect(WebCore::Region::bounds()); }
+    gfx::Rect bounds() const
+    {
+        WebCore::IntRect bounds = WebCore::Region::bounds();
+        return gfx::Rect(bounds.x(), bounds.y(), bounds.width(), bounds.height());
+    }
+
+    class Iterator {
+    public:
+        Iterator(const Region& region);
+        ~Iterator();
+
+        gfx::Rect rect() const {
+            DCHECK(has_rect());
+            if (!has_rect())
+                return gfx::Rect();
+            return gfx::Rect(m_rects[m_pos].x(), m_rects[m_pos].y(), m_rects[m_pos].width(), m_rects[m_pos].height());
+        }
+
+        void next() { ++m_pos; }
+        bool has_rect() const { return m_pos < m_rects.size(); }
+
+        // It is expensive to construct the iterator just to get this size. Only
+        // do this for testing.
+        int size() { return m_rects.size(); }

[enne (OOO), 2012/11/02 20:30:04]

Why don't you just add a NumRects() function?

[danakj, 2012/11/02 20:32:31]

Because it would be super costly with the WebCore implementation, which suggests
that maybe for other Region implementations it would be too. Whereas, there are
a non-zero number of cases where we want the size, and will be iterating
(web_layer_impl.cc - incoming patch version). And constructing and iterator and
taking the size in tests can be slow but we won't care.

+    private:
+        int m_pos;
+        Vector<WebCore::IntRect> m_rects;
+    };
 
 private:
     bool isEmpty() const { return WebCore::Region::isEmpty(); }
-    bool contains(const IntPoint& point) const { return WebCore::Region::contains(point); }
-    bool contains(const IntRect& rect) const { return WebCore::Region::contains(rect); }
-    void subtract(const IntRect& rect) { return WebCore::Region::subtract(rect); }
+    bool contains(const WebCore::IntPoint& point) const { return WebCore::Region::contains(point); }
+    bool contains(const WebCore::IntRect& rect) const { return WebCore::Region::contains(rect); }
+    void subtract(const WebCore::IntRect& rect) { return WebCore::Region::subtract(rect); }
     void subtract(const Region& region) { return WebCore::Region::subtract(region); }
-    void unite(const IntRect& rect) { return WebCore::Region::unite(rect); }
+    void unite(const WebCore::IntRect& rect) { return WebCore::Region::unite(rect); }
     void unite(const Region& region) { return WebCore::Region::unite(region); }
-    void intersect(const IntRect& rect) { return WebCore::Region::intersect(rect); }
+    void intersect(const WebCore::IntRect& rect) { return WebCore::Region::intersect(rect); }
     void intersect(const Region& region) { return WebCore::Region::intersect(region); }
+    Vector<WebCore::IntRect> rects() const { return WebCore::Region::rects(); }
 };
 
-inline Region subtract(const Region& region, const gfx::Rect& rect) { return WebCore::intersect(region, cc::IntRect(rect)); }
-inline Region intersect(const Region& region, const gfx::Rect& rect) { return WebCore::intersect(region, cc::IntRect(rect)); }
+inline Region subtract(const Region& region, const gfx::Rect& rect) { return WebCore::intersect(region, WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height())); }
+inline Region intersect(const Region& region, const gfx::Rect& rect) { return WebCore::intersect(region, WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height())); }
+
+inline Region::Iterator::Iterator(const Region& region)
+    : m_pos(0)
+    , m_rects(region.rects())
+{
+}
+
+inline Region::Iterator::~Iterator() { }
 
 }
 
 #endif  // CC_STUBS_REGION_H_