Fix double lock of texture resource in software renderer

cc/output/software_renderer_unittest.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 "cc/output/software_renderer.h"
 
 #include "base/run_loop.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
@@ skipping 41 matching lines @@
   }
 
   SoftwareRenderer* renderer() const { return renderer_.get(); }
 
   // RendererClient implementation.
   void SetFullRootLayerDamage() override {}
 
   scoped_ptr<SkBitmap> DrawAndCopyOutput(RenderPassList* list,
                                          float device_scale_factor,
                                          gfx::Rect device_viewport_rect) {
+    CHECK(!list->empty());
+    return DrawAndCopyOutput(list,
+                             list->size() - 1,
+                             device_scale_factor,
+                             device_viewport_rect).Pass();

[danakj, 2015/02/05 17:42:21]

you dont need Pass() on a return statement

[danakj, 2015/02/05 18:15:28]

return makes this an xvalue which allows the move constructor to be used. put
more simply when you return the thing no longer has a name here so it is moved.

+  }
+
+  scoped_ptr<SkBitmap> DrawAndCopyOutput(RenderPassList* list,
+                                         size_t index,
+                                         float device_scale_factor,
+                                         gfx::Rect device_viewport_rect) {
     scoped_ptr<SkBitmap> bitmap_result;
     base::RunLoop loop;
 
-    list->back()->copy_requests.push_back(
+    list->at(index)->copy_requests.push_back(
         CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&SoftwareRendererTest::SaveBitmapResult,
                        base::Unretained(&bitmap_result),
                        loop.QuitClosure())));
 
     renderer()->DrawFrame(list,
                           device_scale_factor,
                           device_viewport_rect,
                           device_viewport_rect,
                           false);
@@ skipping 52 matching lines @@
       shared_quad_state, outer_rect, outer_rect, SK_ColorYELLOW, false);
 
   RenderPassList list;
   list.push_back(root_render_pass.Pass());
 
   float device_scale_factor = 1.f;
   gfx::Rect device_viewport_rect(outer_size);
   scoped_ptr<SkBitmap> output =
       DrawAndCopyOutput(&list, device_scale_factor, device_viewport_rect);
   EXPECT_EQ(outer_rect.width(), output->info().fWidth);
-  EXPECT_EQ(outer_rect.width(), output->info().fHeight);
+  EXPECT_EQ(outer_rect.height(), output->info().fHeight);
 
   EXPECT_EQ(SK_ColorYELLOW, output->getColor(0, 0));
   EXPECT_EQ(SK_ColorYELLOW,
             output->getColor(outer_size.width() - 1, outer_size.height() - 1));
   EXPECT_EQ(SK_ColorYELLOW, output->getColor(1, 1));
   EXPECT_EQ(SK_ColorCYAN, output->getColor(1, 2));
   EXPECT_EQ(SK_ColorCYAN,
             output->getColor(inner_size.width() - 1, inner_size.height() - 1));
 }
 
@@ skipping 77 matching lines @@
                      false);
 
   RenderPassList list;
   list.push_back(root_render_pass.Pass());
 
   float device_scale_factor = 1.f;
   gfx::Rect device_viewport_rect(outer_size);
   scoped_ptr<SkBitmap> output =
       DrawAndCopyOutput(&list, device_scale_factor, device_viewport_rect);
   EXPECT_EQ(outer_rect.width(), output->info().fWidth);
-  EXPECT_EQ(outer_rect.width(), output->info().fHeight);
+  EXPECT_EQ(outer_rect.height(), output->info().fHeight);
 
   EXPECT_EQ(SK_ColorYELLOW, output->getColor(0, 0));
   EXPECT_EQ(SK_ColorYELLOW,
             output->getColor(outer_size.width() - 1, outer_size.height() - 1));
   EXPECT_EQ(SK_ColorCYAN, output->getColor(1, 1));
   EXPECT_EQ(SK_ColorCYAN,
             output->getColor(inner_size.width() - 1, inner_size.height() - 1));
 }
 
 TEST_F(SoftwareRendererTest, TileQuadVisibleRect) {
@@ skipping 54 matching lines @@
   quad->visible_rect = visible_rect;
 
   RenderPassList list;
   list.push_back(root_render_pass.Pass());
 
   float device_scale_factor = 1.f;
   gfx::Rect device_viewport_rect(tile_size);
   scoped_ptr<SkBitmap> output =
       DrawAndCopyOutput(&list, device_scale_factor, device_viewport_rect);
   EXPECT_EQ(tile_rect.width(), output->info().fWidth);
-  EXPECT_EQ(tile_rect.width(), output->info().fHeight);
+  EXPECT_EQ(tile_rect.height(), output->info().fHeight);
 
   // Check portion of tile not in visible rect isn't drawn.
   const unsigned int kTransparent = SK_ColorTRANSPARENT;
   EXPECT_EQ(kTransparent, output->getColor(0, 0));
   EXPECT_EQ(kTransparent,
             output->getColor(tile_rect.width() - 1, tile_rect.height() - 1));
   EXPECT_EQ(kTransparent,
             output->getColor(visible_rect.x() - 1, visible_rect.y() - 1));
   EXPECT_EQ(kTransparent,
             output->getColor(visible_rect.right(), visible_rect.bottom()));
@@ skipping 21 matching lines @@
   RenderPassId root_clear_pass_id(1, 0);
   TestRenderPass* root_clear_pass = AddRenderPass(
       &list, root_clear_pass_id, device_viewport_rect, gfx::Transform());
   AddQuad(root_clear_pass, device_viewport_rect, SK_ColorGREEN);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
 
   scoped_ptr<SkBitmap> output =
       DrawAndCopyOutput(&list, device_scale_factor, device_viewport_rect);
   EXPECT_EQ(device_viewport_rect.width(), output->info().fWidth);
-  EXPECT_EQ(device_viewport_rect.width(), output->info().fHeight);
+  EXPECT_EQ(device_viewport_rect.height(), output->info().fHeight);
 
   EXPECT_EQ(SK_ColorGREEN, output->getColor(0, 0));
   EXPECT_EQ(SK_ColorGREEN,
             output->getColor(device_viewport_rect.width() - 1,
                              device_viewport_rect.height() - 1));
 
   list.clear();
 
   // Draw a smaller magenta rect without filling the viewport in a separate
   // frame.
   gfx::Rect smaller_rect(20, 20, 60, 60);
 
   RenderPassId root_smaller_pass_id(2, 0);
   TestRenderPass* root_smaller_pass = AddRenderPass(
       &list, root_smaller_pass_id, device_viewport_rect, gfx::Transform());
   AddQuad(root_smaller_pass, smaller_rect, SK_ColorMAGENTA);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
 
   output = DrawAndCopyOutput(&list, device_scale_factor, device_viewport_rect);
   EXPECT_EQ(device_viewport_rect.width(), output->info().fWidth);
-  EXPECT_EQ(device_viewport_rect.width(), output->info().fHeight);
+  EXPECT_EQ(device_viewport_rect.height(), output->info().fHeight);
 
   // If we didn't clear, the borders should still be green.
   EXPECT_EQ(SK_ColorGREEN, output->getColor(0, 0));
   EXPECT_EQ(SK_ColorGREEN,
             output->getColor(device_viewport_rect.width() - 1,
                              device_viewport_rect.height() - 1));
 
   EXPECT_EQ(SK_ColorMAGENTA,
             output->getColor(smaller_rect.x(), smaller_rect.y()));
   EXPECT_EQ(
@@ skipping 24 matching lines @@
 
   // Interior pass quad has smaller visible rect.
   gfx::Rect interior_visible_rect(30, 30, 40, 40);
   root_clear_pass->quad_list.front()->visible_rect = interior_visible_rect;
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
 
   scoped_ptr<SkBitmap> output =
       DrawAndCopyOutput(&list, device_scale_factor, device_viewport_rect);
   EXPECT_EQ(device_viewport_rect.width(), output->info().fWidth);
-  EXPECT_EQ(device_viewport_rect.width(), output->info().fHeight);
+  EXPECT_EQ(device_viewport_rect.height(), output->info().fHeight);
 
   EXPECT_EQ(SK_ColorGREEN, output->getColor(0, 0));
   EXPECT_EQ(SK_ColorGREEN,
             output->getColor(device_viewport_rect.width() - 1,
                              device_viewport_rect.height() - 1));
 
   // Part outside visible rect should remain green.
   EXPECT_EQ(SK_ColorGREEN,
             output->getColor(smaller_rect.x(), smaller_rect.y()));
   EXPECT_EQ(
       SK_ColorGREEN,
       output->getColor(smaller_rect.right() - 1, smaller_rect.bottom() - 1));
 
   EXPECT_EQ(
       SK_ColorMAGENTA,
       output->getColor(interior_visible_rect.x(), interior_visible_rect.y()));
   EXPECT_EQ(SK_ColorMAGENTA,
             output->getColor(interior_visible_rect.right() - 1,
                              interior_visible_rect.bottom() - 1));
 }
 
+TEST_F(SoftwareRendererTest, DoubleLockTextureCrash) {
+  float device_scale_factor = 1.f;
+  gfx::Rect device_viewport_rect(0, 0, 100, 100);
+  InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
+
+  RenderPassList list;
+
+  gfx::Rect first_rect(0, 0, 50, 50);
+  RenderPassId first_pass_id(3, 2);
+  TestRenderPass* first_pass =
+      AddRenderPass(&list, first_pass_id, first_rect, gfx::Transform());
+  AddQuad(first_pass, first_rect, SK_ColorRED);
+
+  gfx::Rect second_rect(50, 50, 50, 50);
+  RenderPassId second_pass_id(2, 1);
+  TestRenderPass* second_pass =
+      AddRenderPass(&list, second_pass_id, second_rect, gfx::Transform());
+  AddQuad(second_pass, second_rect, SK_ColorBLUE);
+
+  RenderPassId root_clear_pass_id(1, 0);
+  TestRenderPass* root_clear_pass = AddRenderPass(
+      &list, root_clear_pass_id, device_viewport_rect, gfx::Transform());
+  AddRenderPassQuad(root_clear_pass, first_pass);
+  AddRenderPassQuad(root_clear_pass, second_pass);
+  AddQuad(root_clear_pass, device_viewport_rect, SK_ColorGREEN);
+
+  renderer()->DecideRenderPassAllocationsForFrame(list);
+
+  scoped_ptr<SkBitmap> output =
+      DrawAndCopyOutput(&list, 1, device_scale_factor, device_viewport_rect);
+
+  EXPECT_EQ(second_rect.width(), output->info().fWidth);
+  EXPECT_EQ(second_rect.height(), output->info().fHeight);
+
+  EXPECT_EQ(SK_ColorBLUE, output->getColor(0, 0));
+  EXPECT_EQ(SK_ColorBLUE,
+            output->getColor(second_rect.width() - 1,
+                             second_rect.height() - 1));
+  EXPECT_EQ(SK_ColorBLUE,
+            output->getColor(second_rect.width() / 2,
+                             second_rect.height() / 2));
+}
+
 }  // namespace
 }  // namespace cc