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 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_);
   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_;

[piman, 2015/09/16 23:21:09]

return !waiting_for_sync_point_;

[sunnyps, 2015/09/16 23:38:42]

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