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

cc/direct_renderer.cc

 // Copyright 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.
 
 #include "config.h"
 
 #include "CCDirectRenderer.h"
 
 #include "cc/math_util.h"
 #include "ui/gfx/rect_conversions.h"
@@ skipping 142 matching lines @@
 
 void DirectRenderer::drawFrame(const RenderPassList& renderPassesInDrawOrder, const RenderPassIdHashMap& renderPassesById)
 {
     const RenderPass* rootRenderPass = renderPassesInDrawOrder.back();
     DCHECK(rootRenderPass);
 
     DrawingFrame frame;
     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)
         drawRenderPass(frame, renderPassesInDrawOrder[i]);
     finishDrawingFrame(frame);
 }
 
 void DirectRenderer::drawRenderPass(DrawingFrame& frame, const RenderPass* renderPass)
 {
     if (!useRenderPass(frame, renderPass))
         return;
 
     frame.scissorRectInRenderPassSpace = frame.currentRenderPass->outputRect();
     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));
     clearFramebuffer(frame);
 
     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);
         }
     }
 
     CachedTexture* texture = m_renderPassTextures.get(renderPass->id());
     if (texture)
         texture->setIsComplete(!renderPass->hasOcclusionFromOutsideTargetSurface());
 }
@@ skipping 30 matching lines @@
     return cc::IntSize(pass->outputRect().size());
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }