gpu: Remove async texture uploads.

cc/trees/layer_tree_host_pixeltest_blending.cc

 // Copyright 2013 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/layers/picture_image_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/layer_tree_pixel_resource_test.h"
 #include "cc/test/pixel_comparator.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
@@ skipping 259 matching lines @@
     }
 
     RunPixelResourceTest(root, base::FilePath(expected_path));
   }
 
   bool force_antialiasing_;
   bool force_blending_with_shaders_;
 };
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) {
-  RunBlendingWithRootPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW);
+  RunBlendingWithRootPixelTestType(GL_ZERO_COPY_RECT_DRAW);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) {
   RunBlendingWithRootPixelTestType(SOFTWARE);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithBackgroundFilter) {
   const int kLaneWidth = 2;
   const int kLaneHeight = kLaneWidth;
   const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth;
   const int kRootHeight = 2 * kLaneWidth + kLaneHeight;
-  InitializeFromTestCase(GL_ASYNC_UPLOAD_2D_DRAW);
+  InitializeFromTestCase(GL_ZERO_COPY_RECT_DRAW);
 
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSOrange);
 
   // Orange child layers have a background filter set and they will blend with
   // the green background
   for (int i = 0; i < kBlendModesCount; ++i) {
     gfx::Rect child_rect(
         (i + 1) * kLaneWidth, kLaneWidth, kLaneWidth, kLaneHeight);
     scoped_refptr<SolidColorLayer> green_lane =
         CreateSolidColorLayer(child_rect, kCSSGreen);
     background->AddChild(green_lane);
 
     FilterOperations filters;
     filters.Append(FilterOperation::CreateGrayscaleFilter(.75));
     green_lane->SetBackgroundFilters(filters);
     green_lane->SetBlendMode(kBlendModes[i]);
   }
 
   RunPixelResourceTest(
       background, base::FilePath(FILE_PATH_LITERAL("blending_and_filter.png")));
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_GL) {
-  RunBlendingWithTransparentPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW);
+  RunBlendingWithTransparentPixelTestType(GL_ZERO_COPY_RECT_DRAW);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) {
   RunBlendingWithTransparentPixelTestType(SOFTWARE);
 }
 
 // Tests for render passes
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_Software) {
   RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_Software) {
   RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMask_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMask_Software) {
   RunBlendingWithRenderPass(
       SOFTWARE, FILE_PATH_LITERAL("blending_render_pass_mask.png"), kUseMasks);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMaskAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskAA_Software) {
   RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassColorMatrix_Software) {
   RunBlendingWithRenderPass(
       SOFTWARE, FILE_PATH_LITERAL("blending_render_pass.png"), kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassColorMatrixAA_Software) {
   RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_Software) {
   RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_Software) {
   RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 // Tests for render passes forcing shaders for all the blend modes.
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShaders_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShadersAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMask_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMask_GL_TextureRect) {
   RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskAA_GL_TextureRect) {
   RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrix_GL_TextureRect) {
   RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrixAA_GL) {
   RunBlendingWithRenderPass(
-      GL_ASYNC_UPLOAD_2D_DRAW,
+      GL_ZERO_COPY_RECT_DRAW,
       FILE_PATH_LITERAL("blending_render_pass_mask.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID