Removed OLD_SYNC_POINT sync token namespace.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 39 matching lines @@
 
 namespace cc {
 namespace {
 
 gpu::Mailbox MailboxFromChar(char value) {
   gpu::Mailbox mailbox;
   memset(mailbox.name, value, sizeof(mailbox.name));
   return mailbox;
 }
 
+gpu::SyncToken SyncTokenFromUInt(uint32_t value) {
+  return gpu::SyncToken(gpu::CommandBufferNamespace::GPU_IO, 0, 0x123, value);
+}
+
 class MockLayerTreeHost : public LayerTreeHost {
  public:
   static scoped_ptr<MockLayerTreeHost> Create(
       FakeLayerTreeHostClient* client,
       TaskGraphRunner* task_graph_runner) {
     LayerTreeHost::InitParams params;
     params.client = client;
     params.task_graph_runner = task_graph_runner;
     LayerTreeSettings settings;
     params.settings = &settings;
@@ skipping 64 matching lines @@
                void(SharedBitmap* shared_bitmap,
                     const gpu::SyncToken& sync_token,
                     bool lost_resource,
                     BlockingTaskRunner* main_thread_task_runner));
 };
 
 struct CommonMailboxObjects {
   explicit CommonMailboxObjects(SharedBitmapManager* manager)
       : mailbox_name1_(MailboxFromChar('1')),
         mailbox_name2_(MailboxFromChar('2')),
-        sync_token1_(1),
-        sync_token2_(2) {
+        sync_token1_(gpu::CommandBufferNamespace::GPU_IO, 123, 0x234, 1),
+        sync_token2_(gpu::CommandBufferNamespace::GPU_IO, 123, 0x234, 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,
@@ skipping 164 matching lines @@
       test_data_.mailbox1_,
       SingleReleaseCallback::Create(test_data_.release_mailbox1_));
 }
 
 TEST_F(TextureLayerTest, SetTextureMailboxWithoutReleaseCallback) {
   scoped_refptr<TextureLayer> test_layer =
       TextureLayer::CreateForMailbox(layer_settings_, nullptr);
   ASSERT_TRUE(test_layer.get());
 
   // These use the same gpu::Mailbox, but different sync points.
-  TextureMailbox mailbox1(MailboxFromChar('a'), gpu::SyncToken(1),
+  TextureMailbox mailbox1(MailboxFromChar('a'), SyncTokenFromUInt(1),
                           GL_TEXTURE_2D);
-  TextureMailbox mailbox2(MailboxFromChar('a'), gpu::SyncToken(2),
+  TextureMailbox mailbox2(MailboxFromChar('a'), SyncTokenFromUInt(2),
                           GL_TEXTURE_2D);
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Set the mailbox the first time. It should cause a commit.
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   test_layer->SetTextureMailboxWithoutReleaseCallback(mailbox1);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
@@ skipping 83 matching lines @@
   scoped_ptr<SingleReleaseCallbackImpl> compositor2;
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                             base::Unretained(this), &compositor2));
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The compositors both destroy their impl trees before the main thread layer
   // is destroyed.
-  compositor1->Run(gpu::SyncToken(100), false, main_thread_task_runner_.get());
-  compositor2->Run(gpu::SyncToken(200), false, main_thread_task_runner_.get());
+  compositor1->Run(SyncTokenFromUInt(100), false,
+                   main_thread_task_runner_.get());
+  compositor2->Run(SyncTokenFromUInt(200), false,
+                   main_thread_task_runner_.get());
 
   Wait(main_thread_);
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The main thread ref is the last one, so the mailbox is released back to the
   // embedder, with the last sync point provided by the impl trees.
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, gpu::SyncToken(200), false))
+              Release(test_data_.mailbox_name1_, SyncTokenFromUInt(200), false))
       .Times(1);
 
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                             base::Unretained(this)));
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleaseBetween) {
@@ skipping 18 matching lines @@
   // reference to its impl tree.
   scoped_ptr<SingleReleaseCallbackImpl> compositor2;
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                             base::Unretained(this), &compositor2));
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // One compositor destroys their impl tree.
-  compositor1->Run(gpu::SyncToken(100), false, main_thread_task_runner_.get());
+  compositor1->Run(SyncTokenFromUInt(100), false,
+                   main_thread_task_runner_.get());
 
   // Then the main thread reference is destroyed.
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                             base::Unretained(this)));
 
   Wait(main_thread_);
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The second impl reference is destroyed last, causing the mailbox to be
   // released back to the embedder with the last sync point from the impl tree.
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, gpu::SyncToken(200), true))
+              Release(test_data_.mailbox_name1_, SyncTokenFromUInt(200), true))
       .Times(1);
 
-  compositor2->Run(gpu::SyncToken(200), true, main_thread_task_runner_.get());
+  compositor2->Run(SyncTokenFromUInt(200), true,
+                   main_thread_task_runner_.get());
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleasedFirst) {
   scoped_refptr<TextureLayer> test_layer =
       TextureLayer::CreateForMailbox(layer_settings_, nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->task_runner()->PostTask(
@@ skipping 18 matching lines @@
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The main thread reference is destroyed first.
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                             base::Unretained(this)));
 
   // One compositor destroys their impl tree.
-  compositor2->Run(gpu::SyncToken(200), false, main_thread_task_runner_.get());
+  compositor2->Run(SyncTokenFromUInt(200), false,
+                   main_thread_task_runner_.get());
 
   Wait(main_thread_);
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The second impl reference is destroyed last, causing the mailbox to be
   // released back to the embedder with the last sync point from the impl tree.
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, gpu::SyncToken(100), true))
+              Release(test_data_.mailbox_name1_, SyncTokenFromUInt(100), true))
       .Times(1);
 
-  compositor1->Run(gpu::SyncToken(100), true, main_thread_task_runner_.get());
+  compositor1->Run(SyncTokenFromUInt(100), true,
+                   main_thread_task_runner_.get());
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_SecondImplRefShortcut) {
   scoped_refptr<TextureLayer> test_layer =
       TextureLayer::CreateForMailbox(layer_settings_, nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->task_runner()->PostTask(
@@ skipping 18 matching lines @@
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The main thread reference is destroyed first.
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                             base::Unretained(this)));
 
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, gpu::SyncToken(200), true))
+              Release(test_data_.mailbox_name1_, SyncTokenFromUInt(200), true))
       .Times(1);
 
   bool manual_reset = false;
   bool initially_signaled = false;
   base::WaitableEvent begin_capture(manual_reset, initially_signaled);
   base::WaitableEvent wait_for_capture(manual_reset, initially_signaled);
   base::WaitableEvent stop_capture(manual_reset, initially_signaled);
 
   // Post a task to start capturing tasks on the main thread. This will block
   // the main thread until we signal the |stop_capture| event.
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CapturePostTasksAndWait,
                  base::Unretained(this), &begin_capture, &wait_for_capture,
                  &stop_capture));
 
   // Before the main thread capturing starts, one compositor destroys their
   // impl reference. Since capturing did not start, this gets post-tasked to
   // the main thread.
-  compositor1->Run(gpu::SyncToken(100), false, main_thread_task_runner_.get());
+  compositor1->Run(SyncTokenFromUInt(100), false,
+                   main_thread_task_runner_.get());
 
   // Start capturing on the main thread.
   begin_capture.Signal();
   wait_for_capture.Wait();
 
   // Meanwhile, the second compositor released its impl reference, but this task
   // gets shortcutted directly to the main thread. This means the reference is
   // released before compositor1, whose reference will be released later when
   // the post-task is serviced. But since it was destroyed _on the impl thread_
   // last, its sync point values should be used.
-  compositor2->Run(gpu::SyncToken(200), true, main_thread_task_runner_.get());
+  compositor2->Run(SyncTokenFromUInt(200), true,
+                   main_thread_task_runner_.get());
 
   stop_capture.Signal();
   Wait(main_thread_);
 
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
  public:
   TextureLayerImplWithMailboxThreadedCallback()
@@ skipping 838 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