cc: Make separate interface for BeginFrame ipc from OutputSurface

cc/scheduler/scheduler.cc

 // Copyright 2011 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 "cc/scheduler/scheduler.h"
 
 #include <algorithm>
+
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 BeginFrameSource* SchedulerFrameSourcesConstructor::ConstructPrimaryFrameSource(
     Scheduler* scheduler) {
   if (!scheduler->settings_.throttle_frame_production) {
     TRACE_EVENT1("cc",
                  "Scheduler::Scheduler()",
                  "PrimaryFrameSource",
                  "BackToBackBeginFrameSource");
     DCHECK(!scheduler->primary_frame_source_internal_);
     scheduler->primary_frame_source_internal_ =
         BackToBackBeginFrameSource::Create(scheduler->task_runner_.get());
     return scheduler->primary_frame_source_internal_.get();
   } else if (scheduler->settings_.begin_frame_scheduling_enabled) {
     TRACE_EVENT1("cc",
                  "Scheduler::Scheduler()",
                  "PrimaryFrameSource",
-                 "SchedulerClient");
-    return scheduler->client_->ExternalBeginFrameSource();
+                 "ExternalBeginFrameSource");
+    return scheduler->external_begin_frame_source_internal_.get();
   } else {
     TRACE_EVENT1("cc",
                  "Scheduler::Scheduler()",
                  "PrimaryFrameSource",
                  "SyntheticBeginFrameSource");
     scoped_ptr<SyntheticBeginFrameSource> synthetic_source =
         SyntheticBeginFrameSource::Create(scheduler->task_runner_.get(),
                                           scheduler->Now(),
                                           BeginFrameArgs::DefaultInterval());
 
@@ skipping 19 matching lines @@
                                         scheduler->Now(),
                                         base::TimeDelta::FromSeconds(1));
   return scheduler->background_frame_source_internal_.get();
 }
 
 Scheduler::Scheduler(
     SchedulerClient* client,
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    scoped_ptr<ExternalBeginFrameSource> external_begin_frame_source,
     SchedulerFrameSourcesConstructor* frame_sources_constructor)
     : frame_source_(),
       primary_frame_source_(NULL),
       background_frame_source_(NULL),
       primary_frame_source_internal_(),
       background_frame_source_internal_(),
+      external_begin_frame_source_internal_(external_begin_frame_source.Pass()),

[mithro-old, 2014/10/13 02:56:20]

Can we just store this in the primary_frame_source_internal_ instead?

[simonhong, 2014/10/15 01:04:21]

external_begin_frame_source is changed to ref-counted object.
So, it should be stored in the separate member.

       vsync_observer_(NULL),
       settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       begin_retro_frame_posted_(false),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::Scheduler",
                "settings",
                settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
 
+  if (settings_.begin_frame_scheduling_enabled) {
+    DCHECK(external_begin_frame_source_internal_.get());
+    external_begin_frame_source_internal_->SetClientReady();

[mithro-old, 2014/10/13 02:56:20]

I'm unsure what the "SetClientReady" function is for?

[simonhong, 2014/10/15 01:04:21]

SetClientReady() will be used if BeginFrameSource has two state(Create and Run)
and it is created and used on different thread.
CompositorExternalBeginFrameSource can be in runnable state after it is
delivered to scheduler on compositor thread.

+  } else {
+    DCHECK(!external_begin_frame_source_internal_.get());
+  }
+
   begin_retro_frame_closure_ =
       base::Bind(&Scheduler::BeginRetroFrame, weak_factory_.GetWeakPtr());
   begin_impl_frame_deadline_closure_ = base::Bind(
       &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
   poll_for_draw_triggers_closure_ = base::Bind(
       &Scheduler::PollForAnticipatedDrawTriggers, weak_factory_.GetWeakPtr());
   advance_commit_state_closure_ = base::Bind(
       &Scheduler::PollToAdvanceCommitState, weak_factory_.GetWeakPtr());
 
   frame_source_ = BeginFrameSourceMultiplexer::Create();
@@ skipping 637 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc