Adding support for per vertex opacity on textured layer

cc/layer_tree_host_impl_unittest.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/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 2758 matching lines @@
 };
 
 static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvider* provider)
 {
     ResourceProvider::ResourceId resourceId = provider->createResource(0, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
     pass->SetNew(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Transform());
     scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
     sharedState->SetAll(gfx::Transform(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), false, 1);
+    const float vertex_opacity[] = {1, 1, 1, 1};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
-    quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
+    quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), vertex_opacity, false);
 
     pass->AppendSharedQuadState(sharedState.Pass());
     pass->AppendQuad(quad.PassAs<DrawQuad>());
 
     return pass.PassAs<RenderPass>();
 }
 
 TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostOutputSurface)
 {
     int layerId = 1;
@@ skipping 1476 matching lines @@
             isReplica = true;
 
         scoped_ptr<TestRenderPass> renderPass = testData.renderPassCache.take(renderPassId);
 
         // Cycle through quad data and create all quads
         while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
                 scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
                 quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
-                
+
                 renderPass->AppendQuad(quad.PassAs<DrawQuad>());
                 currentChar++;
             } else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
                 // RenderPass draw quad
                 int layerId = *currentChar;
                 currentChar++;
                 ASSERT_TRUE(currentChar);
                 int index = *currentChar;
                 currentChar++;
                 RenderPass::Id newRenderPassId = RenderPass::Id(layerId, index);
                 ASSERT_NE(rootRenderPassId, newRenderPassId);
                 bool hasTexture = false;
                 bool contentsChanged = true;
-                
+
                 if (*currentChar == '[') {
                     currentChar++;
                     while (*currentChar && *currentChar != ']') {
                         switch (*currentChar) {
                         case 'c':
                             contentsChanged = false;
                             break;
                         case 't':
                             hasTexture = true;
                             break;
@@ skipping 49 matching lines @@
                 *pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.layer_id;
                 pos++;
                 *pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.index;
                 pos++;
                 break;
             default:
                 *pos = 'x';
                 pos++;
                 break;
             }
-            
+
             quadListIterator++;
         }
         *pos = '\n';
         pos++;
     }
     *pos = '\0';
 }
 
 // Each RenderPassList is represented by a string which describes the configuration.
 // The syntax of the string is as follows:
@@ skipping 81 matching lines @@
             "A0ssssB0sss\n"
             "B0C0\n"
             "C0D0\n"
             "D0E0\n"
             "E0F0\n"
             "F0G0\n"
             "G0H0\n"
             "H0sssI0sss\n"
             "I0J0\n"
             "J0ssss\n",
-            
+
             "R0sssssA0ssss\n"
         }, {
             "Wide recursion, remove all",
             "R0A0[ct]B0[ct]C0[ct]D0[ct]E0[ct]F0[ct]G0[ct]H0[ct]I0[ct]J0[ct]\n"
             "A0s\n"
             "B0s\n"
             "C0ssss\n"
             "D0ssss\n"
             "E0s\n"
             "F0\n"
             "G0s\n"
             "H0s\n"
             "I0s\n"
             "J0ssss\n",
-            
+
             "R0A0B0C0D0E0F0G0H0I0J0\n"
         }, {
             "Remove passes regardless of cache state",
             "R0ssssA0[ct]sss\n"
             "A0sssB0C0s\n"
             "B0sssD0[c]ssE0[t]F0\n"
             "E0ssssss\n"
             "C0G0\n"
             "D0sssssss\n"
             "F0sssssss\n"
@@ skipping 200 matching lines @@
 // scrolling model, in both x- and y-directions.
 void LayerTreeHostImplTest::pinchZoomPanViewportAndScrollTest(const float deviceScaleFactor)
 {
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
-    // For this test we want to scrolls to move both the document and the 
+    // For this test we want to scrolls to move both the document and the
     // pinchZoomViewport so we can see some scroll component on the implTransform.
     root->setMaxScrollOffset(gfx::Vector2d(3, 4));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
@@ skipping 98 matching lines @@
 // cause both document-scroll and zoomViewport panning.
 void LayerTreeHostImplTest::pinchZoomPanViewportAndScrollBoundaryTest(const float deviceScaleFactor)
 {
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
-    // For this test we want to scrolls to move both the document and the 
+    // For this test we want to scrolls to move both the document and the
     // pinchZoomViewport so we can see some scroll component on the implTransform.
     root->setMaxScrollOffset(gfx::Vector2d(3, 4));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
@@ skipping 99 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc