mus: Embedder can request and observe BeginFrame for embedded client.

ui/aura/mus/window_port_mus.cc

 // Copyright 2016 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 "ui/aura/mus/window_port_mus.h"
 
 #include "base/memory/ptr_util.h"
+#include "cc/ipc/frame_sink_manager.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/client_surface_embedder.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/class_property.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace aura {
 
 namespace {
 // Helper function to get the device_scale_factor() of the display::Display
 // nearest to |window|.
 float ScaleFactorForDisplay(Window* window) {
   return display::Screen::GetScreen()
       ->GetDisplayNearestWindow(window)
       .device_scale_factor();
 }
 }  // namespace
 
 WindowPortMus::WindowMusChangeDataImpl::WindowMusChangeDataImpl() = default;
 
 WindowPortMus::WindowMusChangeDataImpl::~WindowMusChangeDataImpl() = default;
 
+class WindowPortMus::FrameSinkObserver : public cc::mojom::FrameSinkObserver {
+ public:
+  explicit FrameSinkObserver(base::RepeatingClosure begin_frame_callback)
+      : binding_(this),
+        begin_frame_callback_(std::move(begin_frame_callback)) {}
+  ~FrameSinkObserver() override {}
+
+  cc::mojom::FrameSinkObserverPtr GetPtr() {
+    return binding_.CreateInterfacePtrAndBind();
+  }
+
+ private:
+  // cc::mojom::FrameSinkObserver:
+  void OnBeginFrame() override { begin_frame_callback_.Run(); }
+
+  mojo::Binding<cc::mojom::FrameSinkObserver> binding_;
+  base::RepeatingClosure begin_frame_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(FrameSinkObserver);
+};
+
 // static
 WindowMus* WindowMus::Get(Window* window) {
   return WindowPortMus::Get(window);
 }
 
 WindowPortMus::WindowPortMus(WindowTreeClient* client,
                              WindowMusType window_mus_type)
     : WindowMus(window_mus_type), window_tree_client_(client) {}
 
 WindowPortMus::~WindowPortMus() {
@@ skipping 477 matching lines @@
 WindowPortMus::CreateCompositorFrameSink() {
   // TODO(penghuang): Implement it for Mus.
   return nullptr;
 }
 
 cc::SurfaceId WindowPortMus::GetSurfaceId() const {
   // TODO(penghuang): Implement it for Mus.
   return cc::SurfaceId();
 }
 
+void WindowPortMus::SetNeedsBeginFrames(bool needs,
+                                        base::RepeatingClosure callback) {
+  if (!needs) {
+    frame_sink_observer_ = nullptr;
+    return;
+  }
+  if (frame_sink_observer_)
+    return;
+  frame_sink_observer_ =
+      base::MakeUnique<FrameSinkObserver>(std::move(callback));
+  window_tree_client_->RequestBeginFrames(this, frame_sink_observer_->GetPtr());
+}
+
 void WindowPortMus::UpdatePrimarySurfaceInfo() {
   bool embeds_surface = window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
                         window_mus_type() == WindowMusType::EMBED_IN_OWNER;
   if (!embeds_surface || !window_tree_client_->enable_surface_synchronization_)
     return;
 
   if (!frame_sink_id_.is_valid() || !local_surface_id_.is_valid())
     return;
 
   SetPrimarySurfaceInfo(
@@ skipping 10 matching lines @@
   if (!client_surface_embedder_) {
     client_surface_embedder_ = base::MakeUnique<ClientSurfaceEmbedder>(
         window_, window_tree_client_->normal_client_area_insets_);
   }
 
   client_surface_embedder_->SetPrimarySurfaceInfo(primary_surface_info_);
   client_surface_embedder_->SetFallbackSurfaceInfo(fallback_surface_info_);
 }
 
 }  // namespace aura