SurfaceAggregator should check whether output is secure when drawin

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 1858 matching lines @@
     output_surface_ = FakeOutputSurface::CreateSoftware(
         base::WrapUnique(new SoftwareOutputDevice));
     output_surface_->BindToClient(&output_surface_client_);
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
 
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
 
     aggregator_.reset(
         new SurfaceAggregator(&manager_, resource_provider_.get(), false));
+    aggregator_->set_output_is_secure(true);
   }
 
  protected:
   SurfaceManager manager_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<SurfaceAggregator> aggregator_;
 };
@@ skipping 48 matching lines @@
     const gfx::Rect opaque_rect;
     const gfx::Rect visible_rect;
     bool needs_blending = false;
     bool premultiplied_alpha = false;
     const gfx::PointF uv_top_left;
     const gfx::PointF uv_bottom_right;
     SkColor background_color = SK_ColorGREEN;
     const float vertex_opacity[4] = {0.f, 0.f, 1.f, 1.f};
     bool flipped = false;
     bool nearest_neighbor = false;
+    bool secure_output_only = true;
     quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
                  resource_ids[i], gfx::Size(), premultiplied_alpha, uv_top_left,
                  uv_bottom_right, background_color, vertex_opacity, flipped,
-                 nearest_neighbor);
+                 nearest_neighbor, secure_output_only);
   }
   frame_data->render_pass_list.push_back(std::move(pass));
   std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
   frame->delegated_frame_data = std::move(frame_data);
   factory->SubmitCompositorFrame(surface_id, std::move(frame),
                                  SurfaceFactory::DrawCallback());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
@@ skipping 142 matching lines @@
   pass_list = &frame->delegated_frame_data->render_pass_list;
   ASSERT_EQ(1u, pass_list->size());
   EXPECT_EQ(3u, pass_list->back()->shared_quad_state_list.size());
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
+TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {
+  ResourceTrackingSurfaceFactoryClient client;
+  SurfaceFactory factory(&manager_, &client);
+  SurfaceId surface1_id(7u);
+  factory.Create(surface1_id);
+
+  SurfaceId surface2_id(8u);
+  factory.Create(surface2_id);
+
+  ResourceId ids[] = {11, 12, 13};
+  SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
+                                     &factory, surface1_id);
+
+  std::unique_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface1_id);
+
+  RenderPass* render_pass =
+      frame->delegated_frame_data->render_pass_list.back().get();
+
+  EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, render_pass->quad_list.back()->material);
+
+  {
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    std::unique_ptr<RenderPass> pass = RenderPass::Create();
+    pass->id = RenderPassId(1, 1);
+    SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
+    sqs->opacity = 1.f;
+    SurfaceDrawQuad* surface_quad =
+        pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
+    surface_quad->SetNew(sqs, gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1),
+                         surface1_id);
+    pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
+
+    frame_data->render_pass_list.push_back(std::move(pass));
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    frame->delegated_frame_data = std::move(frame_data);
+    factory.SubmitCompositorFrame(surface2_id, std::move(frame),
+                                  SurfaceFactory::DrawCallback());
+  }
+
+  frame = aggregator_->Aggregate(surface2_id);
+  EXPECT_EQ(1u, frame->delegated_frame_data->render_pass_list.size());
+  render_pass = frame->delegated_frame_data->render_pass_list.front().get();
+
+  // Parent has copy request, so texture should not be drawn.
+  EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
+
+  frame = aggregator_->Aggregate(surface2_id);
+  EXPECT_EQ(1u, frame->delegated_frame_data->render_pass_list.size());
+  render_pass = frame->delegated_frame_data->render_pass_list.front().get();
+
+  // Copy request has been executed earlier, so texture should be drawn.
+  EXPECT_EQ(DrawQuad::TEXTURE_CONTENT,
+            render_pass->quad_list.front()->material);
+
+  aggregator_->set_output_is_secure(false);
+
+  frame = aggregator_->Aggregate(surface2_id);
+  render_pass = frame->delegated_frame_data->render_pass_list.back().get();
+
+  // Output is insecure, so texture should be drawn.
+  EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
+
+  factory.Destroy(surface1_id);
+  factory.Destroy(surface2_id);
+}
+
 }  // namespace
 }  // namespace cc