content/gpu: Simplify gpu channel message handling.

content/common/gpu/gpu_command_buffer_stub.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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 266 matching lines @@
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetGetBuffer,
                                     OnSetGetBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ProduceFrontBuffer,
                         OnProduceFrontBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_WaitForTokenInRange,
                                     OnWaitForTokenInRange);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_WaitForGetOffsetInRange,
                                     OnWaitForGetOffsetInRange);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoDecoder,
                                     OnCreateVideoDecoder)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoEncoder,
                                     OnCreateVideoEncoder)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetSurfaceVisible,
                         OnSetSurfaceVisible)
@@ skipping 37 matching lines @@
 }
 
 void GpuCommandBufferStub::PollWork() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::PollWork");
   delayed_work_scheduled_ = false;
   FastSetActiveURL(active_url_, active_url_hash_);
   if (decoder_.get() && !MakeCurrent())
     return;
 
   if (scheduler_) {
-    const uint32_t current_unprocessed_num =
-        channel()->gpu_channel_manager()->UnprocessedOrderNumber();
+    uint32_t current_unprocessed_num =
+        channel()->gpu_channel_manager()->GetUnprocessedOrderNum();
     // We're idle when no messages were processed or scheduled.
     bool is_idle = (previous_processed_num_ == current_unprocessed_num);
     if (!is_idle && !last_idle_time_.is_null()) {
       base::TimeDelta time_since_idle =
           base::TimeTicks::Now() - last_idle_time_;
       base::TimeDelta max_time_since_idle =
           base::TimeDelta::FromMilliseconds(kMaxTimeSinceIdleMs);
 
       // Force idle when it's been too long since last time we were idle.
       if (time_since_idle > max_time_since_idle)
@@ skipping 23 matching lines @@
     return;
   }
 
   if (delayed_work_scheduled_)
     return;
   delayed_work_scheduled_ = true;
 
   // Idle when no messages are processed between now and when
   // PollWork is called.
   previous_processed_num_ =
-      channel()->gpu_channel_manager()->ProcessedOrderNumber();
+      channel()->gpu_channel_manager()->GetProcessedOrderNum();
   if (last_idle_time_.is_null())
     last_idle_time_ = base::TimeTicks::Now();
 
   // IsScheduled() returns true after passing all unschedule fences
   // and this is when we can start performing idle work. Idle work
   // is done synchronously so we can set delay to 0 and instead poll
   // for more work at the rate idle work is performed. This also ensures
   // that idle work is done as efficiently as possible without any
   // unnecessary delays.
   if (scheduler_.get() &&
@@ skipping 373 matching lines @@
     }
   }
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(
     int32 put_offset,
     uint32 flush_count,
     const std::vector<ui::LatencyInfo>& latency_info) {
   TRACE_EVENT1(
       "gpu", "GpuCommandBufferStub::OnAsyncFlush", "put_offset", put_offset);
+  DCHECK(command_buffer_);
 
-  if (ui::LatencyInfo::Verify(latency_info,
+  // We received this message out-of-order. This should not happen but is here
+  // to catch regressions. Ignore the message.
+  DCHECK_LT(flush_count - last_flush_count_, 0x8000000U)
+      << "Received a Flush message out-of-order";

[piman, 2015/09/11 00:38:34]

We really shouldn't make it a DCHECK (NOTREACHED was kinda wrong too), because
we're checking untrusted data.
We can DVLOG though (all that can happen is the client screwing itself up).

[sunnyps, 2015/09/11 01:53:22]

Done.

+
+  if (flush_count > last_flush_count_ &&
+      ui::LatencyInfo::Verify(latency_info,
                               "GpuCommandBufferStub::OnAsyncFlush") &&
       !latency_info_callback_.is_null()) {
     latency_info_callback_.Run(latency_info);
   }
-  DCHECK(command_buffer_.get());
-  if (flush_count - last_flush_count_ < 0x8000000U) {
-    last_flush_count_ = flush_count;
-    command_buffer_->Flush(put_offset);
-  } else {
-    // We received this message out-of-order. This should not happen but is here
-    // to catch regressions. Ignore the message.
-    NOTREACHED() << "Received a Flush message out-of-order";
-  }
 
-  ReportState();
-}
-
-void GpuCommandBufferStub::OnRescheduled() {
+  last_flush_count_ = flush_count;
   gpu::CommandBuffer::State pre_state = command_buffer_->GetLastState();
-  command_buffer_->Flush(command_buffer_->GetPutOffset());
+  command_buffer_->Flush(put_offset);
   gpu::CommandBuffer::State post_state = command_buffer_->GetLastState();
 
   if (pre_state.get_offset != post_state.get_offset)
     ReportState();
 }
 
 void GpuCommandBufferStub::OnRegisterTransferBuffer(
     int32 id,
     base::SharedMemoryHandle transfer_buffer,
     uint32 size) {
@@ skipping 63 matching lines @@
   // encoder is registered as a DestructionObserver of this stub and will
   // self-delete during destruction of this stub.
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetSurfaceVisible");
   if (memory_manager_client_state_)
     memory_manager_client_state_->SetVisible(visible);
 }
 
-void GpuCommandBufferStub::AddSyncPoint(uint32 sync_point) {
+void GpuCommandBufferStub::AddSyncPoint(uint32 sync_point, bool retire) {
   sync_points_.push_back(sync_point);
+  if (retire)
+    OnRetireSyncPoint(sync_point);
 }
 
 void GpuCommandBufferStub::OnRetireSyncPoint(uint32 sync_point) {
   DCHECK(!sync_points_.empty() && sync_points_.front() == sync_point);
   sync_points_.pop_front();
 
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PushTextureUpdates(sync_point);
@@ skipping 277 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content