cc/blimp: Add synchronization for scroll/scale state.

blimp/client/core/compositor/blimp_compositor.cc

 // Copyright 2015 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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 98 matching lines @@
     return DidNotSwapAction::BREAK_PROMISE;
   }
   int64_t TraceId() const override { return 0; }
 
  private:
   std::unique_ptr<cc::CopyOutputRequest> copy_request_;
   base::WeakPtr<BlimpCompositor> compositor_weak_ptr_;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 };
 
+// static
+std::unique_ptr<BlimpCompositor> BlimpCompositor::Create(
+    BlimpCompositorDependencies* compositor_dependencies,
+    BlimpCompositorClient* client,
+    bool use_threaded_layer_tree_host) {
+  std::unique_ptr<BlimpCompositor> compositor =
+      base::WrapUnique(new BlimpCompositor(compositor_dependencies, client,
+                                           use_threaded_layer_tree_host));
+  compositor->Initialize();
+  return compositor;
+}
+
 BlimpCompositor::BlimpCompositor(
     BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client,
     bool use_threaded_layer_tree_host)
     : use_threaded_layer_tree_host_(use_threaded_layer_tree_host),
       client_(client),
       compositor_dependencies_(compositor_dependencies),
       frame_sink_id_(compositor_dependencies_->GetEmbedderDependencies()
                          ->AllocateFrameSinkId()),
       proxy_client_(nullptr),
       compositor_frame_sink_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       outstanding_commits_(0U),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
+}
 
+void BlimpCompositor::Initialize() {
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>();
   GetEmbedderDeps()->GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
-  CreateLayerTreeHost();
+  host_ = CreateLayerTreeHost();
 
   if (use_threaded_layer_tree_host_) {
     std::unique_ptr<cc::ClientPictureCache> client_picture_cache =
         compositor_dependencies_->GetImageSerializationProcessor()
             ->CreateClientPictureCache();
     compositor_state_deserializer_ =
         base::MakeUnique<cc::CompositorStateDeserializer>(
-            host_.get(), std::move(client_picture_cache),
-            base::Bind(&BlimpCompositor::LayerScrolled,
-                       weak_ptr_factory_.GetWeakPtr()),
-            this);
+            host_.get(), std::move(client_picture_cache), this);
   }
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyLayerTreeHost();
   GetEmbedderDeps()->GetSurfaceManager()->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
 }
 
+bool BlimpCompositor::IsVisible() const {
+  return host_->IsVisible();
+}
+
+bool BlimpCompositor::HasPendingFrameUpdateFromEngine() const {
+  return pending_frame_update_.get() != nullptr;
+}
+
 void BlimpCompositor::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> copy_request,
     bool flush_pending_update) {
   // If we don't have a FrameSink, fail right away.
   if (!surface_factory_)
     return;
 
   if (!use_threaded_layer_tree_host_) {
     RequestCopyOfOutputDeprecated(std::move(copy_request));
     return;
@@ skipping 21 matching lines @@
     surface_factory_->RequestCopyOfSurface(local_frame_id_,
                                            std::move(copy_request));
     return;
   }
 
   pending_commit_trackers_.push_back(
       std::make_pair(outstanding_commits_, std::move(copy_request)));
 }
 
 void BlimpCompositor::UpdateLayerTreeHost() {
+  DCHECK(use_threaded_layer_tree_host_);
+
+  // UpdateLayerTreeHost marks the end of reporting of any deltas from the impl
+  // thread. So send a client state update if the local state was modified now.
+  FlushClientState();
+
   if (pending_frame_update_) {
     DCHECK(use_threaded_layer_tree_host_);
     compositor_state_deserializer_->DeserializeCompositorUpdate(
         pending_frame_update_->layer_tree_host());
     pending_frame_update_ = nullptr;
     cc::proto::CompositorMessage frame_ack;
     frame_ack.set_frame_ack(true);
     client_->SendCompositorMessage(frame_ack);
   }
+
+  // Send back any deltas that have not yet been resolved on the main thread
+  // back to the impl thread.
+  compositor_state_deserializer_->SendUnappliedDeltasToLayerTreeHost();
+}
+
+void BlimpCompositor::ApplyViewportDeltas(
+    const gfx::Vector2dF& inner_delta,
+    const gfx::Vector2dF& outer_delta,
+    const gfx::Vector2dF& elastic_overscroll_delta,
+    float page_scale,
+    float top_controls_delta) {
+  DCHECK(use_threaded_layer_tree_host_);
+  compositor_state_deserializer_->ApplyViewportDeltas(
+      inner_delta, outer_delta, elastic_overscroll_delta, page_scale,
+      top_controls_delta);
 }
 
 void BlimpCompositor::RequestNewCompositorFrameSink() {
   DCHECK(!surface_factory_);
   DCHECK(!compositor_frame_sink_request_pending_);
 
   compositor_frame_sink_request_pending_ = true;
   GetEmbedderDeps()->GetContextProviders(
       base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
@@ skipping 35 matching lines @@
 }
 
 void BlimpCompositor::OnCompositorMessageReceived(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
   if (message->has_to_impl()) {
     HandleCompositorMessageToImpl(std::move(message));
     return;
   }
 
   DCHECK(use_threaded_layer_tree_host_);
-  DCHECK(message->has_layer_tree_host())
-      << "The engine only sends frame updates";
-  DCHECK(!pending_frame_update_)
-      << "We should have only a single frame in flight";
+  cc::proto::CompositorMessage* message_received = message.get();
 
-  UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
-                          (float)message->ByteSize() / 1024);
-  BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
-  pending_frame_update_ = std::move(message);
-  host_->SetNeedsAnimate();
+  if (message_received->has_layer_tree_host()) {
+    DCHECK(!pending_frame_update_)
+        << "We should have only a single frame in flight";
+
+    UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
+                            (float)message->ByteSize() / 1024);
+    BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
+
+    pending_frame_update_ = std::move(message);
+    outstanding_commits_++;
+    host_->SetNeedsAnimate();
+  }
+
+  if (message_received->client_state_update_ack()) {
+    DCHECK(client_state_update_ack_pending_);
+
+    client_state_update_ack_pending_ = false;
+    compositor_state_deserializer_->DidApplyStateUpdatesOnEngine();
+
+    // If there are any updates that we have queued because we were waiting for
+    // an ack, send them now.
+    FlushClientState();
+  }
 }
 
 void BlimpCompositor::HandleCompositorMessageToImpl(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
   DCHECK(!use_threaded_layer_tree_host_);
   DCHECK(message->has_to_impl());
 
   const cc::proto::CompositorMessageToImpl to_impl_proto = message->to_impl();
   DCHECK(to_impl_proto.has_message_type());
 
@@ skipping 130 matching lines @@
 void BlimpCompositor::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   DCHECK(surface_factory_);
   compositor_dependencies_->GetCompositorTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &BlimpCompositorFrameSinkProxyClient::ReclaimCompositorResources,
           proxy_client_, resources));
 }
 
-bool BlimpCompositor::ShouldRetainClientScroll(
-    int engine_layer_id,
-    const gfx::ScrollOffset& new_offset) {
-  // TODO(khushalsagar): Update when adding scroll/scale sync. See
-  // crbug.com/648442.
-  return true;
+void BlimpCompositor::DidUpdateLocalState() {
+  client_state_dirty_ = true;
 }
 
-bool BlimpCompositor::ShouldRetainClientPageScale(float new_page_scale) {
-  // TODO(khushalsagar): Update when adding scroll/scale sync. See
-  // crbug.com/648442.
-  return true;
-}
+void BlimpCompositor::FlushClientState() {
+  // If the client state has not been modified, we don't need to send an update.
+  if (!client_state_dirty_)
+    return;
 
-void BlimpCompositor::LayerScrolled(int engine_layer_id) {
-  DCHECK(use_threaded_layer_tree_host_);
+  // If we had sent an update and an ack for it is still pending, we can't send
+  // another update till the ack is received.
+  if (client_state_update_ack_pending_)
+    return;
+
+  cc::proto::CompositorMessage message;
+  message.set_frame_ack(false);
+  compositor_state_deserializer_->PullClientStateUpdate(
+      message.mutable_client_state_update());
+
+  client_state_dirty_ = false;
+  client_state_update_ack_pending_ = true;
+  client_->SendCompositorMessage(message);
 }
 
 CompositorDependencies* BlimpCompositor::GetEmbedderDeps() {
   return compositor_dependencies_->GetEmbedderDependencies();
 }
 
 void BlimpCompositor::DestroyDelegatedContent() {
   if (local_frame_id_.is_null())
     return;
 
   // Remove any references for the surface layer that uses this
   // |local_frame_id_|.
   layer_->RemoveAllChildren();
   surface_factory_->Destroy(local_frame_id_);
   local_frame_id_ = cc::LocalFrameId();
 }
 
-void BlimpCompositor::CreateLayerTreeHost() {
-  DCHECK(!host_);
+std::unique_ptr<cc::LayerTreeHostInProcess>
+BlimpCompositor::CreateLayerTreeHost() {
+  std::unique_ptr<cc::LayerTreeHostInProcess> host;
 
-  // Create the LayerTreeHost
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
   params.task_graph_runner = compositor_dependencies_->GetTaskGraphRunner();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   if (!use_threaded_layer_tree_host_) {
     params.image_serialization_processor =
         compositor_dependencies_->GetImageSerializationProcessor();
   }
 
   cc::LayerTreeSettings* settings =
       compositor_dependencies_->GetLayerTreeSettings();
   params.settings = settings;
 
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       compositor_dependencies_->GetCompositorTaskRunner();
 
   if (use_threaded_layer_tree_host_) {
-    host_ = cc::LayerTreeHostInProcess::CreateThreaded(compositor_task_runner,
-                                                       &params);
+    host = cc::LayerTreeHostInProcess::CreateThreaded(compositor_task_runner,
+                                                      &params);
   } else {
-    host_ = cc::LayerTreeHostInProcess::CreateRemoteClient(
+    host = cc::LayerTreeHostInProcess::CreateRemoteClient(
         this /* remote_proto_channel */, compositor_task_runner, &params);
   }
+
+  return host;
 }
 
 void BlimpCompositor::DestroyLayerTreeHost() {
   DCHECK(host_);
 
   // Tear down the output surface connection with the old LayerTreeHost
   // instance.
   DestroyDelegatedContent();
   surface_factory_.reset();
 
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp