Automatically redraw the display on resume.

services/surfaces/display_impl.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 "services/surfaces/display_impl.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/surfaces/display.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
@@ skipping 59 matching lines @@
   pending_callback_ = callback;
   if (display_)
     Draw();
 }
 
 void DisplayImpl::Draw() {
   gfx::Size frame_size =
       pending_frame_->passes[0]->output_rect.To<gfx::Rect>().size();
   last_submitted_frame_size_ = frame_size;
   display_->Resize(frame_size);
-  factory_.SubmitFrame(cc_id_,
-                       pending_frame_.To<scoped_ptr<cc::CompositorFrame>>(),
-                       base::Bind(&CallCallback, pending_callback_));
+  factory_.SubmitFrame(
+      cc_id_, pending_frame_.Clone().To<scoped_ptr<cc::CompositorFrame>>(),

[blundell, 2015/05/04 15:11:49]

I'm not an expert here, but this feels to me like instead the DisplayImpl should
be passing some notification up the chain in OutputSurfaceLost() that would
allow the higher-level object to kick off a flow that would result in
DisplayImpl::SubmitFrame() being called if desired. Does that make sense, or
does this approach seem correct?

[jamesr, 2015/05/04 18:03:22]

Hmm, do we need new frame data in the recover path or do we just need to tell
something that it needs to draw?  The factory_ is preserving the frame data so
we shouldn't need to submit anything again unless the frame contains resources
that need to be regenerated (which in practice won't normally happen since the
view_manager doesn't submit any resources).

The scheduler should know to draw after loss, but it doesn't know to resize
things

+      base::Bind(&CallCallback, pending_callback_));
   scheduler_->SetNeedsDraw();
-  pending_frame_.reset();
   pending_callback_.reset();
 }
 
 void DisplayImpl::DisplayDamaged() {
 }
 
 void DisplayImpl::DidSwapBuffers() {
 }
 
 void DisplayImpl::DidSwapBuffersComplete() {
@@ skipping 32 matching lines @@
   DCHECK(returner_);
 
   mojo::Array<mojo::ReturnedResourcePtr> ret(resources.size());
   for (size_t i = 0; i < resources.size(); ++i) {
     ret[i] = mojo::ReturnedResource::From(resources[i]);
   }
   returner_->ReturnResources(ret.Pass());
 }
 
 }  // namespace surfaces