Update from https://crrev.com/308331

cc/layers/texture_layer_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/layers/texture_layer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 83 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeTextureLayerClient);
 };
 
 class MockMailboxCallback {
  public:
   MOCK_METHOD3(Release,
                void(const gpu::Mailbox& mailbox,
                     uint32 sync_point,
                     bool lost_resource));
   MOCK_METHOD3(Release2,
-               void(base::SharedMemory* shared_memory,
+               void(SharedBitmap* shared_bitmap,
                     uint32 sync_point,
                     bool lost_resource));
   MOCK_METHOD4(ReleaseImpl,
                void(const gpu::Mailbox& mailbox,
                     uint32 sync_point,
                     bool lost_resource,
                     BlockingTaskRunner* main_thread_task_runner));
   MOCK_METHOD4(ReleaseImpl2,
-               void(base::SharedMemory* shared_memory,
+               void(SharedBitmap* shared_bitmap,
                     uint32 sync_point,
                     bool lost_resource,
                     BlockingTaskRunner* main_thread_task_runner));
 };
 
 struct CommonMailboxObjects {
-  CommonMailboxObjects()
+  explicit CommonMailboxObjects(SharedBitmapManager* manager)
       : mailbox_name1_(MailboxFromChar('1')),
         mailbox_name2_(MailboxFromChar('2')),
         sync_point1_(1),
-        sync_point2_(2),
-        shared_memory_(new base::SharedMemory) {
+        sync_point2_(2) {
     release_mailbox1_ = base::Bind(&MockMailboxCallback::Release,
                                    base::Unretained(&mock_callback_),
                                    mailbox_name1_);
     release_mailbox2_ = base::Bind(&MockMailboxCallback::Release,
                                    base::Unretained(&mock_callback_),
                                    mailbox_name2_);
     release_mailbox1_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl,
                                         base::Unretained(&mock_callback_),
                                         mailbox_name1_);
     release_mailbox2_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl,
                                         base::Unretained(&mock_callback_),
                                         mailbox_name2_);
     const uint32 arbitrary_target1 = GL_TEXTURE_2D;
     const uint32 arbitrary_target2 = GL_TEXTURE_EXTERNAL_OES;
     mailbox1_ = TextureMailbox(mailbox_name1_, arbitrary_target1, sync_point1_);
     mailbox2_ = TextureMailbox(mailbox_name2_, arbitrary_target2, sync_point2_);
     gfx::Size size(128, 128);
-    EXPECT_TRUE(shared_memory_->CreateAndMapAnonymous(4 * size.GetArea()));
-    release_mailbox3_ = base::Bind(&MockMailboxCallback::Release2,
-                                   base::Unretained(&mock_callback_),
-                                   shared_memory_.get());
-    release_mailbox3_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl2,
-                                        base::Unretained(&mock_callback_),
-                                        shared_memory_.get());
-    mailbox3_ = TextureMailbox(shared_memory_.get(), size);
+    shared_bitmap_ = manager->AllocateSharedBitmap(size);
+    DCHECK(shared_bitmap_);
+    release_mailbox3_ =
+        base::Bind(&MockMailboxCallback::Release2,
+                   base::Unretained(&mock_callback_), shared_bitmap_.get());
+    release_mailbox3_impl_ =
+        base::Bind(&MockMailboxCallback::ReleaseImpl2,
+                   base::Unretained(&mock_callback_), shared_bitmap_.get());
+    mailbox3_ = TextureMailbox(shared_bitmap_.get(), size);
   }
 
   gpu::Mailbox mailbox_name1_;
   gpu::Mailbox mailbox_name2_;
   MockMailboxCallback mock_callback_;
   ReleaseCallback release_mailbox1_;
   ReleaseCallback release_mailbox2_;
   ReleaseCallback release_mailbox3_;
   ReleaseCallbackImpl release_mailbox1_impl_;
   ReleaseCallbackImpl release_mailbox2_impl_;
   ReleaseCallbackImpl release_mailbox3_impl_;
   TextureMailbox mailbox1_;
   TextureMailbox mailbox2_;
   TextureMailbox mailbox3_;
   uint32 sync_point1_;
   uint32 sync_point2_;
-  scoped_ptr<base::SharedMemory> shared_memory_;
+  scoped_ptr<SharedBitmap> shared_bitmap_;
 };
 
 class TextureLayerTest : public testing::Test {
  public:
   TextureLayerTest()
       : fake_client_(
             FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D)),
-        host_impl_(&proxy_, &shared_bitmap_manager_) {}
+        host_impl_(&proxy_, &shared_bitmap_manager_),
+        test_data_(&shared_bitmap_manager_) {}
 
  protected:
   virtual void SetUp() {
     layer_tree_host_.reset(new MockLayerTreeHost(&fake_client_));
     EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
     layer_tree_host_->SetViewportSize(gfx::Size(10, 10));
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   }
 
   virtual void TearDown() {
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
 
     layer_tree_host_->SetRootLayer(nullptr);
     layer_tree_host_ = nullptr;
   }
 
   scoped_ptr<MockLayerTreeHost> layer_tree_host_;
   FakeImplProxy proxy_;
   FakeLayerTreeHostClient fake_client_;
   TestSharedBitmapManager shared_bitmap_manager_;
   FakeLayerTreeHostImpl host_impl_;
+  CommonMailboxObjects test_data_;
 };
 
 TEST_F(TextureLayerTest, CheckPropertyChangeCausesCorrectBehavior) {
   scoped_refptr<TextureLayer> test_layer =
       TextureLayer::CreateForMailbox(nullptr);
   EXPECT_SET_NEEDS_COMMIT(1, layer_tree_host_->SetRootLayer(test_layer));
 
   // Test properties that should call SetNeedsCommit.  All properties need to
   // be set to new values in order for SetNeedsCommit to be called.
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetFlipped(false));
@@ skipping 94 matching lines @@
 class TextureLayerWithMailboxTest : public TextureLayerTest {
  protected:
   virtual void TearDown() {
     Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
     EXPECT_CALL(test_data_.mock_callback_,
                 Release(test_data_.mailbox_name1_,
                         test_data_.sync_point1_,
                         false)).Times(1);
     TextureLayerTest::TearDown();
   }
-
-  CommonMailboxObjects test_data_;
 };
 
 TEST_F(TextureLayerWithMailboxTest, ReplaceMailboxOnMainThreadBeforeCommit) {
   scoped_refptr<TextureLayer> test_layer =
       TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
@@ skipping 28 matching lines @@
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   test_layer->SetTextureMailbox(
       test_data_.mailbox3_,
       SingleReleaseCallback::Create(test_data_.release_mailbox3_));
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   EXPECT_CALL(test_data_.mock_callback_,
-              Release2(test_data_.shared_memory_.get(),
-                       0, false))
-      .Times(1);
+              Release2(test_data_.shared_bitmap_.get(), 0, false)).Times(1);
   test_layer->SetTextureMailbox(TextureMailbox(), nullptr);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test destructor.
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   test_layer->SetTextureMailbox(
       test_data_.mailbox1_,
       SingleReleaseCallback::Create(test_data_.release_mailbox1_));
 }
@@ skipping 70 matching lines @@
  protected:
   void InitializeOnMain() {
     main_thread_task_runner_ =
         BlockingTaskRunner::Create(main_thread_.message_loop_proxy());
   }
 
   scoped_ptr<TestMailboxHolder::MainThreadReference>
       main_ref_;
   base::Thread main_thread_;
   scoped_ptr<BlockingTaskRunner> main_thread_task_runner_;
-  CommonMailboxObjects test_data_;
 };
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_BothReleaseThenMain) {
   scoped_refptr<TextureLayer> test_layer =
       TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
@@ skipping 473 matching lines @@
   }
 
   bool WillDraw(TextureLayerImpl* layer, DrawMode mode) {
     bool will_draw = layer->WillDraw(
         mode, host_impl_.active_tree()->resource_provider());
     if (will_draw)
       layer->DidDraw(host_impl_.active_tree()->resource_provider());
     return will_draw;
   }
 
-  CommonMailboxObjects test_data_;
   FakeLayerTreeHostClient fake_client_;
 };
 
 // Test conditions for results of TextureLayerImpl::WillDraw under
 // different configurations of different mailbox, texture_id, and draw_mode.
 TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) {
   EXPECT_CALL(
       test_data_.mock_callback_,
       ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_point1_, false, _))
       .Times(AnyNumber());
   EXPECT_CALL(test_data_.mock_callback_,
-              ReleaseImpl2(test_data_.shared_memory_.get(), 0, false, _))
+              ReleaseImpl2(test_data_.shared_bitmap_.get(), 0, false, _))
       .Times(AnyNumber());
   // Hardware mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(
         test_data_.mailbox1_,
         SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
@@ skipping 590 matching lines @@
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc