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");
+    DCHECK(scheduler->external_begin_frame_source_internal_.get());
+    scheduler->external_begin_frame_source_internal_->SetClientReady();
+    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_refptr<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),
       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) {
@@ skipping 21 matching lines @@
       frame_sources_constructor->ConstructPrimaryFrameSource(this);
   frame_source_->AddSource(primary_frame_source_);
 
   // Background ticking frame source
   background_frame_source_ =
       frame_sources_constructor->ConstructBackgroundFrameSource(this);
   frame_source_->AddSource(background_frame_source_);
 }
 
 Scheduler::~Scheduler() {
+  if (frame_source_->NeedsBeginFrames())
+    frame_source_->SetNeedsBeginFrames(false);
 }
 
 base::TimeTicks Scheduler::Now() const {
   base::TimeTicks now = gfx::FrameTime::Now();
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.now"),
                "Scheduler::Now",
                "now",
                now);
   return now;
 }
@@ skipping 613 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