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 180 matching lines @@
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(use_virtualized_gl_context),
       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),
       delayed_work_scheduled_(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_);
 
@@ skipping 401 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 170 matching lines @@
 
 bool GpuCommandBufferStub::OnWaitSyncPoint(uint32 sync_point) {
   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);

[jbauman, 2015/09/16 21:31:26]

DCHECK(!waiting_for_sync_point_);

[sunnyps, 2015/09/16 23:08:31]

Done.

-  ++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 false;

[piman, 2015/09/16 21:46:29]

AddSyncPointCallback may call the callback synchronously, if the sync point was
already retired. While there is the IsSyncPointRetired test above, you can't
rely on its result if the sync point is retired on another thread.

[sunnyps, 2015/09/16 23:08:31]

Done.

 }
 
 void GpuCommandBufferStub::OnWaitSyncPointCompleted(uint32 sync_point) {
+  DCHECK(waiting_for_sync_point_);
+  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