Making OutputSurface a begin frame source and vsync source.

cc/output/output_surface.cc

 // Copyright (c) 2013 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/output/output_surface.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
+#include "base/debug/trace_event_argument.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/scheduler/delay_based_time_source.h"
@@ skipping 12 matching lines @@
 
 const size_t kGpuLatencyHistorySize = 60;
 const double kGpuLatencyEstimationPercentile = 90.0;
 }
 
 namespace cc {
 
 OutputSurface::OutputSurface(
     const scoped_refptr<ContextProvider>& context_provider)
     : client_(NULL),
+      vsync_observer_(NULL),
+      begin_frame_observer_(NULL),
       context_provider_(context_provider),
       device_scale_factor_(-1),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
       gpu_latency_history_(kGpuLatencyHistorySize) {
 }
 
 OutputSurface::OutputSurface(scoped_ptr<SoftwareOutputDevice> software_device)
     : client_(NULL),
+      vsync_observer_(NULL),
+      begin_frame_observer_(NULL),
       software_device_(software_device.Pass()),
       device_scale_factor_(-1),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
       gpu_latency_history_(kGpuLatencyHistorySize) {
 }
 
 OutputSurface::OutputSurface(
     const scoped_refptr<ContextProvider>& context_provider,
     scoped_ptr<SoftwareOutputDevice> software_device)
     : client_(NULL),
+      vsync_observer_(NULL),
+      begin_frame_observer_(NULL),
       context_provider_(context_provider),
       software_device_(software_device.Pass()),
       device_scale_factor_(-1),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
       gpu_latency_history_(kGpuLatencyHistorySize) {
 }
 
 void OutputSurface::CommitVSyncParameters(base::TimeTicks timebase,
                                           base::TimeDelta interval) {
   TRACE_EVENT2("cc",
                "OutputSurface::CommitVSyncParameters",
                "timebase",
                (timebase - base::TimeTicks()).InSecondsF(),
                "interval",
                interval.InSecondsF());
-  client_->CommitVSyncParameters(timebase, interval);
+  if (vsync_observer_)
+    vsync_observer_->OnUpdateVSyncParameters(timebase, interval);
+}
+
+void OutputSurface::SetNeedsBeginFrames(bool needs_begin_frames) {
+  needs_begin_frames_ = needs_begin_frames;
+}
+bool OutputSurface::NeedsBeginFrames() const {
+  return needs_begin_frames_;
+}
+void OutputSurface::AsValueInto(base::debug::TracedValue* dict) const {
+  dict->SetString("type", "OutputSurface");
 }
 
 // Forwarded to OutputSurfaceClient
 void OutputSurface::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "OutputSurface::SetNeedsRedrawRect");
   client_->SetNeedsRedrawRect(damage_rect);
 }
 
 void OutputSurface::ReclaimResources(const CompositorFrameAck* ack) {
   client_->ReclaimResources(ack);
@@ skipping 267 matching lines @@
   TRACE_EVENT1("cc", "OutputSurface::SetMemoryPolicy",
                "bytes_limit_when_visible", policy.bytes_limit_when_visible);
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (policy.bytes_limit_when_visible)
     client_->SetMemoryPolicy(policy);
 }
 
 }  // namespace cc