List sync points to wait on in AsyncFlush message

content/common/gpu/gpu_channel.cc

 // Copyright (c) 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 80 matching lines @@
   void OnFilterAdded(IPC::Sender* sender) override {
     DCHECK(!sender_);
     sender_ = sender;
   }
 
   void OnFilterRemoved() override {
     DCHECK(sender_);
     sender_ = NULL;
   }
 
+  struct MessageStatus {
+    int routing_id;
+    bool forwarded;
+    bool handled;
+  };
+
+  void OnRetireSyncPoint(uint32 sync_point) {
+    if (future_sync_points_) {
+      current_status_.handled = false;
+    } else {
+      DLOG(ERROR) << "Untrusted client should not send "
+                     "GpuCommandBufferMsg_RetireSyncPoint message";
+      current_status_.forwarded = false;
+    }
+  }
+
+  void OnAsyncFlush(int32 put_offset,
+                    uint32 flush_count,
+                    const std::vector<uint32>& sync_points,
+                    const std::vector<ui::LatencyInfo>& latency_info) {
+    std::vector<uint32> sanitized_sync_points;
+    for (uint32 sync_point : sync_points) {
+      if (sync_point_manager_->WasSyncPointGenerated(sync_point))
+        sanitized_sync_points.push_back(sync_point);
+    }
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&GpuChannel::OnMessageReceived),
+                   gpu_channel_,
+                   GpuCommandBufferMsg_AsyncFlush(
+                       current_status_.routing_id, put_offset, flush_count,
+                       sanitized_sync_points, latency_info)));
+  }
+
+  void OnInsertSyncPoint(bool retire, uint32* sync_point) {
+    if (!future_sync_points_ && !retire) {
+      *sync_point = 0;
+      LOG(ERROR) << "Untrusted contexts can't create future sync points";
+      current_status_.forwarded = false;
+      return;
+    }
+    *sync_point = sync_point_manager_->GenerateSyncPoint();
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&GpuChannelMessageFilter::InsertSyncPointOnMainThread,
+                   gpu_channel_, sync_point_manager_,
+                   current_status_.routing_id, retire, *sync_point));
+  }
+
   bool OnMessageReceived(const IPC::Message& message) override {
     DCHECK(sender_);
 
-    bool handled = false;
-    if ((message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) &&
-        !future_sync_points_) {
-      DLOG(ERROR) << "Untrusted client should not send "
-                     "GpuCommandBufferMsg_RetireSyncPoint message";
-      return true;
+    current_status_.routing_id = message.routing_id();
+    current_status_.forwarded = true;
+    current_status_.handled = true;
+    IPC_BEGIN_MESSAGE_MAP(GpuChannelMessageFilter, message)
+      IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RetireSyncPoint,
+                          OnRetireSyncPoint)
+      IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush)
+      IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_InsertSyncPoint,
+                          OnInsertSyncPoint)
+      IPC_MESSAGE_UNHANDLED(current_status_.handled = false)
+    IPC_END_MESSAGE_MAP()
+
+    if (current_status_.forwarded) {
+      // All other messages get processed by the GpuChannel.
+      messages_forwarded_to_channel_++;
+      if (preempting_flag_.get())
+        pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
+      UpdatePreemptionState();
     }
 
-    if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
-      Tuple1<bool> retire;
-      IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
-      if (!GpuCommandBufferMsg_InsertSyncPoint::ReadSendParam(&message,
-                                                              &retire)) {
-        reply->set_reply_error();
-        Send(reply);
-        return true;
-      }
-      if (!future_sync_points_ && !retire.a) {
-        LOG(ERROR) << "Untrusted contexts can't create future sync points";
-        reply->set_reply_error();
-        Send(reply);
-        return true;
-      }
-      uint32 sync_point = sync_point_manager_->GenerateSyncPoint();
-      GpuCommandBufferMsg_InsertSyncPoint::WriteReplyParams(reply, sync_point);
-      Send(reply);
-      message_loop_->PostTask(
-          FROM_HERE,
-          base::Bind(&GpuChannelMessageFilter::InsertSyncPointOnMainThread,
-                     gpu_channel_,
-                     sync_point_manager_,
-                     message.routing_id(),
-                     retire.a,
-                     sync_point));
-      handled = true;
-    }
-
-    // All other messages get processed by the GpuChannel.
-    messages_forwarded_to_channel_++;
-    if (preempting_flag_.get())
-      pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
-    UpdatePreemptionState();
-
-    return handled;
+    return current_status_.handled;
   }
 
   void MessageProcessed(uint64 messages_processed) {
     while (!pending_messages_.empty() &&
            pending_messages_.front().message_number <= messages_processed)
       pending_messages_.pop();
     UpdatePreemptionState();
   }
 
   void SetPreemptingFlagAndSchedulingState(
@@ skipping 217 matching lines @@
         gpu_channel->MessageProcessed();
       }
     }
     manager->RetireSyncPoint(sync_point);
   }
 
   // NOTE: this weak pointer is never dereferenced on the IO thread, it's only
   // passed through - therefore the WeakPtr assumptions are respected.
   base::WeakPtr<GpuChannel> gpu_channel_;
   IPC::Sender* sender_;
+  MessageStatus current_status_;
   scoped_refptr<gpu::SyncPointManager> sync_point_manager_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
   std::queue<PendingMessage> pending_messages_;
 
   // Count of the number of IPCs forwarded to the GpuChannel.
   uint64 messages_forwarded_to_channel_;
 
   base::OneShotTimer<GpuChannelMessageFilter> timer_;
@@ skipping 460 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content