Enable the Sky compositor again

sky/compositor/layer_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 "sky/compositor/layer_host.h"
 
 #include "base/message_loop/message_loop.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/gpu/gl_context.h"
 #include "mojo/services/public/cpp/surfaces/surfaces_utils.h"
 #include "mojo/skia/ganesh_context.h"
 #include "sky/compositor/layer.h"
 
 namespace sky {
 
 LayerHost::LayerHost(LayerHostClient* client)
     : client_(client),
+      state_(kIdle),
       surface_holder_(this, client->GetShell()),
       gl_context_(mojo::GLContext::Create(client->GetShell())),
       ganesh_context_(gl_context_),
       resource_manager_(gl_context_),
       scheduler_(this, base::MessageLoop::current()->task_runner()) {
   scheduler_.UpdateVSync(
       TimeInterval(base::TimeTicks(), base::TimeDelta::FromSecondsD(1.0 / 60)));
 }
 
 LayerHost::~LayerHost() {
 }
 
 void LayerHost::SetNeedsAnimate() {
   scheduler_.SetNeedsFrame();
+  state_ = kWaitingForBeginFrame;
 }
 
 void LayerHost::SetRootLayer(scoped_refptr<Layer> layer) {
   DCHECK(!root_layer_.get());
   root_layer_ = layer;
   root_layer_->set_host(this);
 }
 
 void LayerHost::OnSurfaceIdAvailable(mojo::SurfaceIdPtr surface_id) {
   client_->OnSurfaceIdAvailable(surface_id.Pass());
+
+  if (state_ == kWaitingForSurfaceToUploadFrame)
+    Upload(root_layer_.get());
 }
 
 void LayerHost::ReturnResources(
     mojo::Array<mojo::ReturnedResourcePtr> resources) {
   resource_manager_.ReturnResources(resources.Pass());
 }
 
 void LayerHost::BeginFrame(base::TimeTicks frame_time,
                            base::TimeTicks deadline) {
+  DCHECK_EQ(state_, kWaitingForBeginFrame);
+  state_ = kProducingFrame;
   client_->BeginFrame(frame_time);
 
   {
     mojo::GaneshContext::Scope scope(&ganesh_context_);
     ganesh_context_.gr()->resetContext();
     root_layer_->Display();
   }
 
   Upload(root_layer_.get());
+
+  if (state_ == kProducingFrame)
+    state_ = kIdle;
 }
 
 void LayerHost::Upload(Layer* layer) {
+  if (!surface_holder_.IsReadyForFrame()) {
+    if (state_ == kProducingFrame)

[esprehn, 2014/11/21 19:34:45]

What schedules the eventual upload if it wasn't ready on the first try?

[abarth-chromium, 2014/11/21 20:01:17]

The OnSurfaceIdAvailable callback is called whenever we attach to a surface.  If
we haven't attached to a surface yet, we just want until the next
OnSurfaceIdAvailable callback.  I can add a comment explaining that if you like.

+      state_ = kWaitingForSurfaceToUploadFrame;
+    return;
+  }
+
   gfx::Size size = layer->size();
   surface_holder_.SetSize(size);
 
   mojo::FramePtr frame = mojo::Frame::New();
   frame->resources.resize(0u);
 
   mojo::Rect bounds;
   bounds.width = size.width();
   bounds.height = size.height();
   mojo::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
@@ skipping 31 matching lines @@
 
   frame->resources.push_back(resource.Pass());
   quad->texture_quad_state = texture_state.Pass();
   pass->quads.push_back(quad.Pass());
 
   frame->passes.push_back(pass.Pass());
   surface_holder_.SubmitFrame(frame.Pass());
 }
 
 }  // namespace sky