Add a full Blimp integration test.

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 50 matching lines @@
     int render_widget_id,
     BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client)
     : render_widget_id_(render_widget_id),
       client_(client),
       compositor_dependencies_(compositor_dependencies),
       output_surface_(nullptr),
       output_surface_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
+      outstanding_commits_(0U),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
       GetEmbedderDeps()->AllocateSurfaceClientId());
   GetEmbedderDeps()->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
   CreateLayerTreeHost();
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyLayerTreeHost();
   GetEmbedderDeps()->GetSurfaceManager()->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
+
+  CheckPendingCommitCounts(true /* flush */);
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
+
+  if (!visible)
+    CheckPendingCommitCounts(true /* flush */);
 }
 
 bool BlimpCompositor::OnTouchEvent(const ui::MotionEvent& motion_event) {
   if (input_manager_)
     return input_manager_->OnTouchEvent(motion_event);
   return false;
 }
 
+void BlimpCompositor::NotifyWhenDonePendingCommits(base::Closure callback) {
+  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::RequestNewOutputSurface() {
   DCHECK(!surface_factory_);
   DCHECK(!output_surface_request_pending_);
 
   output_surface_request_pending_ = true;
   GetEmbedderDeps()->GetContextProviders(
       base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BlimpCompositor::DidInitializeOutputSurface() {
   output_surface_request_pending_ = false;
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
   BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
+
+  DCHECK_GT(outstanding_commits_, 0U);
+  outstanding_commits_--;
+
+  CheckPendingCommitCounts(false /* flush */);
 }
 
 void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   remote_proto_channel_receiver_ = receiver;
 }
 
 void BlimpCompositor::SendCompositorProto(
     const cc::proto::CompositorMessage& proto) {
   client_->SendCompositorMessage(render_widget_id_, proto);
 }
 
 void BlimpCompositor::OnCompositorMessageReceived(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
   DCHECK(message->has_to_impl());
   const cc::proto::CompositorMessageToImpl& to_impl_proto = message->to_impl();
 
   DCHECK(to_impl_proto.has_message_type());
+
+  if (to_impl_proto.message_type() ==
+      cc::proto::CompositorMessageToImpl::START_COMMIT) {
+    outstanding_commits_++;
+  }
+
   switch (to_impl_proto.message_type()) {
     case cc::proto::CompositorMessageToImpl::UNKNOWN:
       NOTIMPLEMENTED() << "Ignoring message of UNKNOWN type";
       break;
     case cc::proto::CompositorMessageToImpl::START_COMMIT:
       UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
                               (float)message->ByteSize() / 1024);
     default:
       // We should have a receiver if we're getting compositor messages that
       // are not INITIALIZE_IMPL or CLOSE_IMPL.
@@ skipping 165 matching lines @@
   input_manager_.reset();
 
   // Cancel any outstanding OutputSurface requests.  That way if we get an async
   // callback related to the old request we know to drop it.
   output_surface_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
+void BlimpCompositor::CheckPendingCommitCounts(bool flush) {
+  for (auto it = pending_commit_trackers_.begin();
+       it != pending_commit_trackers_.end();) {
+    if (flush || --it->first == 0) {
+      it->second.Run();
+      it = pending_commit_trackers_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 }  // namespace client
 }  // namespace blimp