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 42 matching lines @@
   cc::Surface* surface = manager->GetSurfaceForId(id);
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 }  // namespace
 
+// 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_);
 
   CheckPendingCommitCounts(true /* flush */);
@@ skipping 10 matching lines @@
   if (outstanding_commits_ == 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
     return;
   }
 
   pending_commit_trackers_.push_back(
       std::make_pair(outstanding_commits_, callback));
 }
 
 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()));
 }
 
 void BlimpCompositor::DidInitializeCompositorFrameSink() {
   compositor_frame_sink_request_pending_ = false;
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
   BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
 
+  // TODO(khushalsagar): Fix before landing, the code here assumes that every
+  // commit came from the engine. :X.
+  return;
+
   DCHECK_GT(outstanding_commits_, 0U);
   outstanding_commits_--;
 
   CheckPendingCommitCounts(false /* flush */);
 }
 
 void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   DCHECK(!use_threaded_layer_tree_host_);
   remote_proto_channel_receiver_ = receiver;
 }
 
 void BlimpCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
   DCHECK(!use_threaded_layer_tree_host_);
   client_->SendCompositorMessage(proto);
 }
 
 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);
-  pending_frame_update_ = std::move(message);
-  outstanding_commits_++;
-  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);
+    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 118 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_);
-  VLOG(1) << "Creating LayerTreeHost.";
+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.gpu_memory_buffer_manager =
       GetEmbedderDeps()->GetGpuMemoryBufferManager();
   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_);
-  VLOG(1) << "Destroying LayerTreeHost.";
 
   // 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
@@ skipping 11 matching lines @@
       it->second.Run();
       it = pending_commit_trackers_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 }  // namespace client
 }  // namespace blimp