content/gpu: Simplify stub scheduling.

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 185 matching lines @@
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(use_virtualized_gl_context),
       command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
       stream_id_(stream_id),
       route_id_(route_id),
       surface_id_(surface_id),
       software_(software),
       last_flush_count_(0),
       last_memory_allocation_valid_(false),
       watchdog_(watchdog),
-      sync_point_wait_count_(0),
+      waiting_for_sync_point_(false),
       previous_processed_num_(0),
       active_url_(active_url),
       total_gpu_memory_(0) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
@@ skipping 109 matching lines @@
 
   DCHECK(handled);
   return handled;
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
 bool GpuCommandBufferStub::IsScheduled() {
-  return (!scheduler_.get() || scheduler_->IsScheduled());
+  return (!scheduler_.get() || scheduler_->scheduled());
 }
 
 void GpuCommandBufferStub::PollWork() {
   // Post another delayed task if we have not yet reached the time at which
   // we should process delayed work.
   base::TimeTicks current_time = base::TimeTicks::Now();
   DCHECK(!process_delayed_work_time_.is_null());
   if (process_delayed_work_time_ > current_time) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&GpuCommandBufferStub::PollWork, AsWeakPtr()),
@@ skipping 71 matching lines @@
       channel()->gpu_channel_manager()->GetProcessedOrderNum();
   if (last_idle_time_.is_null())
     last_idle_time_ = current_time;
 
   // 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() &&
-      scheduler_->IsScheduled() &&
+  if (scheduler_.get() && scheduler_->scheduled() &&
       scheduler_->HasMoreIdleWork()) {
     delay = base::TimeDelta();
   }
 
   process_delayed_work_time_ = current_time + delay;
   task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&GpuCommandBufferStub::PollWork, AsWeakPtr()),
       delay);
 }
 
@@ skipping 203 matching lines @@
       base::Bind(&GpuCommandBufferStub::OnWaitSyncPoint,
                  base::Unretained(this)));
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GpuCommandBufferStub::PutChanged, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&gpu::GpuScheduler::SetGetBuffer,
                  base::Unretained(scheduler_.get())));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&GpuCommandBufferStub::OnParseError, base::Unretained(this)));
-  scheduler_->SetSchedulingChangedCallback(
-      base::Bind(&GpuChannel::StubSchedulingChanged,
-                 base::Unretained(channel_)));
+  scheduler_->SetSchedulingChangedCallback(base::Bind(
+      &GpuCommandBufferStub::OnSchedulingChanged, base::Unretained(this)));
 
   if (watchdog_) {
     scheduler_->SetCommandProcessedCallback(
         base::Bind(&GpuCommandBufferStub::OnCommandProcessed,
                    base::Unretained(this)));
   }
 
   const size_t kSharedStateSize = sizeof(gpu::CommandBufferSharedState);
   if (!shared_state_shm->Map(kSharedStateSize)) {
     DLOG(ERROR) << "Failed to map shared state buffer.";
@@ skipping 75 matching lines @@
   // Tell the browser about this context loss as well, so it can
   // determine whether client APIs like WebGL need to be immediately
   // blocked from automatically running.
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DidLoseContext(
       handle_.is_null(), state.context_lost_reason, active_url_));
 
   CheckContextLost();
 }
 
+void GpuCommandBufferStub::OnSchedulingChanged(bool scheduled) {
+  TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnSchedulingChanged", "scheduled",
+               scheduled);
+  channel_->OnStubSchedulingChanged(this, scheduled);
+}
+
 void GpuCommandBufferStub::OnWaitForTokenInRange(int32 start,
                                                  int32 end,
                                                  IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnWaitForTokenInRange");
   DCHECK(command_buffer_.get());
   CheckContextLost();
   if (wait_for_token_)
     LOG(ERROR) << "Got WaitForToken command while currently waiting for token.";
   wait_for_token_ =
       make_scoped_ptr(new WaitForCommandState(start, end, reply_message));
@@ skipping 162 matching lines @@
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PushTextureUpdates(sync_point);
 
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   manager->sync_point_manager()->RetireSyncPoint(sync_point);
 }
 
 bool GpuCommandBufferStub::OnWaitSyncPoint(uint32 sync_point) {
+  DCHECK(!waiting_for_sync_point_);
+  DCHECK(scheduler_->scheduled());
   if (!sync_point)
     return true;
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   if (manager->sync_point_manager()->IsSyncPointRetired(sync_point)) {
     PullTextureUpdates(sync_point);
     return true;
   }
 
-  if (sync_point_wait_count_ == 0) {
-    TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncPoint", this,
-                             "GpuCommandBufferStub", this);
-  }
+  TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncPoint", this, "GpuCommandBufferStub",
+                           this);
+
   scheduler_->SetScheduled(false);
-  ++sync_point_wait_count_;
+  waiting_for_sync_point_ = true;
   manager->sync_point_manager()->AddSyncPointCallback(
       sync_point,
       base::Bind(&RunOnThread, task_runner_,
                  base::Bind(&GpuCommandBufferStub::OnWaitSyncPointCompleted,
                             this->AsWeakPtr(), sync_point)));
-  return scheduler_->IsScheduled();
+  return !waiting_for_sync_point_;
 }
 
 void GpuCommandBufferStub::OnWaitSyncPointCompleted(uint32 sync_point) {
+  DCHECK(waiting_for_sync_point_);
+  DCHECK(!scheduler_->scheduled());
+  TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncPoint", this, "GpuCommandBufferStub",
+                         this);
   PullTextureUpdates(sync_point);
-  --sync_point_wait_count_;
-  if (sync_point_wait_count_ == 0) {
-    TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncPoint", this,
-                           "GpuCommandBufferStub", this);
-  }
+  waiting_for_sync_point_ = false;
   scheduler_->SetScheduled(true);
 }
 
 void GpuCommandBufferStub::PullTextureUpdates(uint32 sync_point) {
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PullTextureUpdates(sync_point);
 }
 
@@ skipping 232 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content