Added a way for sync point clients to issue out of order waits.

gpu/command_buffer/service/sync_point_manager_unittest.cc

 // Copyright (c) 2015 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 <stdint.h>
 
 #include <queue>
 
 #include "base/bind.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
@@ skipping 67 matching lines @@
   EXPECT_EQ(1u, order_num);
 
   EXPECT_EQ(0u, order_data->current_order_num());
   EXPECT_EQ(0u, order_data->processed_order_num());
   EXPECT_EQ(order_num, order_data->unprocessed_order_num());
 
   order_data->BeginProcessingOrderNumber(order_num);
   EXPECT_EQ(order_num, order_data->current_order_num());
   EXPECT_EQ(0u, order_data->processed_order_num());
   EXPECT_EQ(order_num, order_data->unprocessed_order_num());
+  EXPECT_TRUE(order_data->IsProcessingOrderNumber());
+
+  order_data->PauseProcessingOrderNumber(order_num);
+  EXPECT_FALSE(order_data->IsProcessingOrderNumber());
+
+  order_data->BeginProcessingOrderNumber(order_num);
+  EXPECT_TRUE(order_data->IsProcessingOrderNumber());
 
   order_data->FinishProcessingOrderNumber(order_num);
   EXPECT_EQ(order_num, order_data->current_order_num());
   EXPECT_EQ(order_num, order_data->processed_order_num());
   EXPECT_EQ(order_num, order_data->unprocessed_order_num());
+  EXPECT_FALSE(order_data->IsProcessingOrderNumber());
 }
 
 TEST_F(SyncPointManagerTest, SyncPointClientRegistration) {
   const CommandBufferNamespace kNamespaceId =
       gpu::CommandBufferNamespace::GPU_IO;
   const uint64_t kBufferId = 0x123;
 
   scoped_refptr<SyncPointClientState> empty_state =
       sync_point_manager_->GetSyncPointClientState(kNamespaceId, kBufferId);
   EXPECT_FALSE(empty_state);
@@ skipping 17 matching lines @@
 
   scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
   scoped_ptr<SyncPointClient> client =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId);
   scoped_refptr<SyncPointClientState> client_state = client->client_state();
 
   EXPECT_EQ(0u, client_state->fence_sync_release());
   EXPECT_FALSE(client_state->IsFenceSyncReleased(1));
 
+  const uint32_t order_num =
+      order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
+  order_data->BeginProcessingOrderNumber(order_num);
   client->ReleaseFenceSync(1);
+  order_data->FinishProcessingOrderNumber(order_num);
 
   EXPECT_EQ(1u, client_state->fence_sync_release());
   EXPECT_TRUE(client_state->IsFenceSyncReleased(1));
 }
 
 TEST_F(SyncPointManagerTest, MultipleClientsPerOrderData) {
   const CommandBufferNamespace kNamespaceId =
       gpu::CommandBufferNamespace::GPU_IO;
   const uint64_t kBufferId1 = 0x123;
   const uint64_t kBufferId2 = 0x234;
 
   scoped_refptr<SyncPointOrderData> order_data = SyncPointOrderData::Create();
   scoped_ptr<SyncPointClient> client1 =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId1);
   scoped_ptr<SyncPointClient> client2 =
       sync_point_manager_->CreateSyncPointClient(order_data, kNamespaceId,
                                                  kBufferId2);
 
   scoped_refptr<SyncPointClientState> client_state1 = client1->client_state();
   scoped_refptr<SyncPointClientState> client_state2 = client2->client_state();
 
+  const uint32_t order_num =
+      order_data->GenerateUnprocessedOrderNumber(sync_point_manager_.get());
+  order_data->BeginProcessingOrderNumber(order_num);
   client1->ReleaseFenceSync(1);
+  order_data->FinishProcessingOrderNumber(order_num);
 
   EXPECT_TRUE(client_state1->IsFenceSyncReleased(1));
   EXPECT_FALSE(client_state2->IsFenceSyncReleased(1));
 }
 
 TEST_F(SyncPointManagerTest, BasicFenceSyncWaitRelease) {
   const CommandBufferNamespace kNamespaceId =
       gpu::CommandBufferNamespace::GPU_IO;
   const uint64_t kBufferId1 = 0x123;
   const uint64_t kBufferId2 = 0x234;
@@ skipping 244 matching lines @@
   EXPECT_EQ(10, test_num);
 
   // Beginning order [4] should immediately trigger the release.
   release_stream.BeginProcessing();
   ASSERT_EQ(4u, release_stream.order_data->current_order_num());
   EXPECT_TRUE(release_stream.client->client_state()->IsFenceSyncReleased(1));
   EXPECT_EQ(123, test_num);
 }
 
 }  // namespace gpu