cc: Implement unified BeginFrame on aura

content/browser/compositor/delegated_frame_host.cc

 // Copyright 2014 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 "content/browser/compositor/delegated_frame_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
+#include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/compositor/resize_lock.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/common/gpu/client/gl_helper.h"
+#include "content/common/view_messages.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/dip_util.h"
@@ skipping 18 matching lines @@
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost
 
-DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
+DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client,
+                                       bool begin_frame_scheduling_enabled)
     : client_(client),
       compositor_(nullptr),
       use_surfaces_(UseSurfacesEnabled()),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
-      delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
+      delegated_frame_evictor_(new DelegatedFrameEvictor(this)),
+      begin_frame_scheduling_enabled_(begin_frame_scheduling_enabled),
+      needs_begin_frames_(false) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
   if (surface_id_.is_null() && !frame_provider_.get() &&
       !released_front_lock_.get()) {
     if (compositor_)
       released_front_lock_ = compositor_->GetCompositorLock();
@@ skipping 744 matching lines @@
       callback,
       subscriber_texture,
       base::Passed(&release_callback));
   yuv_readback_pipeline->ReadbackYUV(texture_mailbox.mailbox(),
                                      texture_mailbox.sync_point(),
                                      video_frame.get(),
                                      region_in_frame.origin(),
                                      finished_callback);
 }
 
+void DelegatedFrameHost::OnSetNeedsBeginFrames(bool needs_begin_frames) {
+  DCHECK(begin_frame_scheduling_enabled_);
+
+ if (needs_begin_frames_ == needs_begin_frames)
+   return;
+
+  needs_begin_frames_ = needs_begin_frames;
+
+  // In some cases, BeginFrame is needed before |client_|'s window is added
+  // in the root window hierarchy.
+  if (!compositor_)
+    return;
+
+  if (needs_begin_frames)
+    StartObservingBeginFrames();
+  else
+    StopObservingBeginFrames();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::CompositorObserver implementation:
 
 void DelegatedFrameHost::OnCompositingDidCommit(
     ui::Compositor* compositor) {
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
     can_lock_compositor_ = YES_CAN_LOCK;
     if (resize_lock_.get() && resize_lock_->GrabDeferredLock())
       can_lock_compositor_ = YES_DID_LOCK;
   }
@@ skipping 29 matching lines @@
     can_lock_compositor_ = NO_PENDING_RENDERER_FRAME;
   }
 }
 
 void DelegatedFrameHost::OnCompositingShuttingDown(ui::Compositor* compositor) {
   DCHECK_EQ(compositor, compositor_);
   ResetCompositor();
   DCHECK(!compositor_);
 }
 
-void DelegatedFrameHost::OnUpdateVSyncParameters(
-    base::TimeTicks timebase,
-    base::TimeDelta interval) {
-  vsync_timebase_ = timebase;
-  vsync_interval_ = interval;
-  if (client_->DelegatedFrameHostIsVisible())
-    client_->DelegatedFrameHostUpdateVSyncParameters(timebase, interval);
+///////////////////////////////////////////////////////////////////////////////
+// ui::CompositorBeginFrameObserver implementation.
+void DelegatedFrameHost::OnSendBeginFrame(const cc::BeginFrameArgs& args) {
+  DCHECK(begin_frame_scheduling_enabled_);
+
+  client_->DelegatedFrameHostSendBeginFrame(args);
+  last_sent_begin_frame_args_ = args;
+  vsync_timebase_ = args.frame_time;
+  vsync_interval_ = args.interval;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ImageTransportFactoryObserver implementation:
 
 void DelegatedFrameHost::OnLostResources() {
   if (frame_provider_.get() || !surface_id_.is_null())
     EvictDelegatedFrame();
   idle_frame_subscriber_textures_.clear();
   yuv_readback_pipeline_.reset();
 
   client_->DelegatedFrameHostOnLostCompositorResources();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, private:
 
 DelegatedFrameHost::~DelegatedFrameHost() {
   DCHECK(!compositor_);
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   if (!surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
   if (resource_collection_.get())
     resource_collection_->SetClient(NULL);
-
-  DCHECK(!vsync_manager_.get());
 }
 
 void DelegatedFrameHost::RunOnCommitCallbacks() {
   for (std::vector<base::Closure>::const_iterator
       it = on_compositing_did_commit_callbacks_.begin();
       it != on_compositing_did_commit_callbacks_.end(); ++it) {
     it->Run();
   }
   on_compositing_did_commit_callbacks_.clear();
 }
 
 void DelegatedFrameHost::AddOnCommitCallbackAndDisableLocks(
     const base::Closure& callback) {
   DCHECK(compositor_);
 
   can_lock_compositor_ = NO_PENDING_COMMIT;
   if (!callback.is_null())
     on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
 void DelegatedFrameHost::SetCompositor(ui::Compositor* compositor) {
   DCHECK(!compositor_);
   if (!compositor)
     return;
   compositor_ = compositor;
   compositor_->AddObserver(this);
-  DCHECK(!vsync_manager_.get());
-  vsync_manager_ = compositor_->vsync_manager();
-  vsync_manager_->AddObserver(this);
+
+  if (begin_frame_scheduling_enabled_ && needs_begin_frames_)
+    StartObservingBeginFrames();
 }
 
 void DelegatedFrameHost::ResetCompositor() {
   if (!compositor_)
     return;
   RunOnCommitCallbacks();
   if (resize_lock_) {
     resize_lock_.reset();
     client_->DelegatedFrameHostResizeLockWasReleased();
   }
   if (compositor_->HasObserver(this))
     compositor_->RemoveObserver(this);
-  if (vsync_manager_.get()) {
-    vsync_manager_->RemoveObserver(this);
-    vsync_manager_ = NULL;
-  }
+
+  if (begin_frame_scheduling_enabled_ && needs_begin_frames_)
+    StopObservingBeginFrames();
+
   compositor_ = nullptr;
 }
 
 void DelegatedFrameHost::LockResources() {
   DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->LockFrame();
 }
 
 void DelegatedFrameHost::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   if (!request_copy_of_output_callback_for_testing_.is_null())
     request_copy_of_output_callback_for_testing_.Run(request.Pass());
   else
     client_->DelegatedFrameHostGetLayer()->RequestCopyOfOutput(request.Pass());
 }
 
 void DelegatedFrameHost::UnlockResources() {
   DCHECK(frame_provider_.get() || !surface_id_.is_null());
   delegated_frame_evictor_->UnlockFrame();
 }
 
+void DelegatedFrameHost::StartObservingBeginFrames() {
+  DCHECK(begin_frame_scheduling_enabled_);
+  DCHECK(compositor_);
+
+  compositor_->AddBeginFrameObserver(this, last_sent_begin_frame_args_);
+}
+
+void DelegatedFrameHost::StopObservingBeginFrames() {
+  DCHECK(begin_frame_scheduling_enabled_);
+  DCHECK(compositor_);
+
+  compositor_->RemoveBeginFrameObserver(this);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::LayerOwnerDelegate implementation:
 
 void DelegatedFrameHost::OnLayerRecreated(ui::Layer* old_layer,
                                                 ui::Layer* new_layer) {
   // The new_layer is the one that will be used by our Window, so that's the one
   // that should keep our frame. old_layer will be returned to the
   // RecreateLayer caller, and should have a copy.
   if (frame_provider_.get()) {
     new_layer->SetShowDelegatedContent(frame_provider_.get(),
                                        current_frame_size_in_dip_);
   }
   if (!surface_id_.is_null()) {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
     new_layer->SetShowSurface(
         surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
         base::Bind(&RequireCallback, base::Unretained(manager)),
         current_surface_size_, current_scale_factor_,
         current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content