Make gfx::Rect class operations consistently mutate the class they are called on.

Currently some methods mutate the class, and some return a new value, requiring
API users to know what kind of method they are calling each time, and making
inconsistent code. For example:

gfx::Rect rect;
rect.Inset(1, 1, 1, 1);
rect = rect.Intersect(other_rect);
rect.Offset(1, 1);

Instead of:

gfx::Rect rect;
rect.Inset(1, 1, 1, 1);
rect.Intersect(other_rect);
rect.Offset(1, 1);

We could go either way - making the class immutable or all methods return a new
instance - but I believe it is better to instead make all methods mutate the
class. This allows for shorter lines of code by avoiding having to repeat the
object's name twice in order to change it.

This patch changes gfx::Rect classes and all the callsites that uses these
methods. It should make no change in behaviour, so no new tests added.

R=sky
BUG=147395

Review URL: https://codereview.chromium.org/11110004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@163579 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 13 insertions, 9 deletions

diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc
index 3f77a55..4101ab7 100644
--- a/cc/delegated_renderer_layer_impl.cc
+++ b/cc/delegated_renderer_layer_impl.cc
@@ -58,7 +58,8 @@ void DelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<RenderPass>& re
 
     if (!m_renderPassesInDrawOrder.isEmpty()) {
         gfx::RectF newRootDamage = m_renderPassesInDrawOrder.last()->damageRect();
-        m_renderPassesInDrawOrder.last()->setDamageRect(oldRootDamage.Union(newRootDamage));
+        newRootDamage.Union(oldRootDamage);
+        m_renderPassesInDrawOrder.last()->setDamageRect(newRootDamage);
     }
 }
 
diff --git a/cc/direct_renderer.cc b/cc/direct_renderer.cc
index 907850b..d38834d 100644
--- a/cc/direct_renderer.cc
+++ b/cc/direct_renderer.cc
@@ -160,7 +160,7 @@ void DirectRenderer::drawFrame(const RenderPassList& renderPassesInDrawOrder, co
     frame.renderPassesById = &renderPassesById;
     frame.rootRenderPass = rootRenderPass;
     frame.rootDamageRect = capabilities().usingPartialSwap ? rootRenderPass->damageRect() : rootRenderPass->outputRect();
-    frame.rootDamageRect = frame.rootDamageRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
+    frame.rootDamageRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
 
     beginDrawingFrame(frame);
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
@@ -177,7 +177,7 @@ void DirectRenderer::drawRenderPass(DrawingFrame& frame, const RenderPass* rende
     if (frame.rootDamageRect != frame.rootRenderPass->outputRect()) {
         WebTransformationMatrix inverseTransformToRoot = frame.currentRenderPass->transformToRootTarget().inverse();
         gfx::RectF damageRectInRenderPassSpace = MathUtil::projectClippedRect(inverseTransformToRoot, cc::FloatRect(frame.rootDamageRect));
-        frame.scissorRectInRenderPassSpace = frame.scissorRectInRenderPassSpace.Intersect(damageRectInRenderPassSpace);
+        frame.scissorRectInRenderPassSpace.Intersect(damageRectInRenderPassSpace);
     }
 
     enableScissorTestRect(moveScissorToWindowSpace(frame, frame.scissorRectInRenderPassSpace));
@@ -185,7 +185,8 @@ void DirectRenderer::drawRenderPass(DrawingFrame& frame, const RenderPass* rende
 
     const QuadList& quadList = renderPass->quadList();
     for (QuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it) {
-        gfx::RectF quadScissorRect = frame.scissorRectInRenderPassSpace.Intersect((*it)->clippedRectInTarget());
+        gfx::RectF quadScissorRect = frame.scissorRectInRenderPassSpace;
+        quadScissorRect.Intersect((*it)->clippedRectInTarget());
         if (!quadScissorRect.IsEmpty()) {
             enableScissorTestRect(moveScissorToWindowSpace(frame, quadScissorRect));
             drawQuad(frame, *it);
diff --git a/cc/draw_quad.cc b/cc/draw_quad.cc
index 9671b11..9250274 100644
--- a/cc/draw_quad.cc
+++ b/cc/draw_quad.cc
@@ -43,7 +43,8 @@ gfx::Rect DrawQuad::opaqueRect() const
 
 void DrawQuad::setQuadVisibleRect(gfx::Rect quadVisibleRect)
 {
-    m_quadVisibleRect = quadVisibleRect.Intersect(m_quadRect);
+    m_quadVisibleRect = quadVisibleRect;
+    m_quadVisibleRect.Intersect(m_quadRect);
 }
 
 unsigned DrawQuad::size() const
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index 042410a..361ced1 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -453,7 +453,7 @@ scoped_ptr<ScopedTexture> GLRenderer::drawBackgroundFilters(DrawingFrame& frame,
     filters.getOutsets(top, right, bottom, left);
     deviceRect.Inset(-left, -top, -right, -bottom);
 
-    deviceRect = deviceRect.Intersect(frame.currentRenderPass->outputRect());
+    deviceRect.Intersect(frame.currentRenderPass->outputRect());
 
     scoped_ptr<ScopedTexture> deviceBackgroundTexture = ScopedTexture::create(m_resourceProvider);
     if (!getFramebufferTexture(deviceBackgroundTexture.get(), cc::IntRect(deviceRect)))
@@ -1013,7 +1013,7 @@ void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDra
 void GLRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
-    m_swapBufferRect = m_swapBufferRect.Union(gfx::ToEnclosingRect(frame.rootDamageRect));
+    m_swapBufferRect.Union(gfx::ToEnclosingRect(frame.rootDamageRect));
 
     GLC(m_context, m_context->disable(GL_SCISSOR_TEST));
     GLC(m_context, m_context->disable(GL_BLEND));
@@ -1111,7 +1111,7 @@ bool GLRenderer::swapBuffers()
 
     if (m_capabilities.usingPartialSwap) {
         // If supported, we can save significant bandwidth by only swapping the damaged/scissored region (clamped to the viewport)
-        m_swapBufferRect = m_swapBufferRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
+        m_swapBufferRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
         int flippedYPosOfRectBottom = viewportHeight() - m_swapBufferRect.y() - m_swapBufferRect.height();
         m_context->postSubBufferCHROMIUM(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height());
     } else {
diff --git a/cc/software_renderer.cc b/cc/software_renderer.cc
index 4720b04..05b7a11 100644
--- a/cc/software_renderer.cc
+++ b/cc/software_renderer.cc
@@ -255,7 +255,8 @@ void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureD
 
     // FIXME: Add support for non-premultiplied alpha.
     ResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
-    gfx::RectF uvRect = quad->uvRect().Scale(quad->quadRect().width(), quad->quadRect().height());
+    gfx::RectF uvRect = quad->uvRect();
+    uvRect.Scale(quad->quadRect().width(), quad->quadRect().height());
     SkIRect skUvRect = toSkIRect(gfx::ToEnclosingRect(uvRect));
     if (quad->flipped())
         m_skCurrentCanvas->scale(1, -1);