Teach SkyShell.apk to stop posting frames when not visible

sky/shell/ui/engine.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 "sky/shell/ui/engine.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/threading/worker_pool.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 41 matching lines @@
 Engine::Config::Config() {
 }
 
 Engine::Config::~Config() {
 }
 
 Engine::Engine(const Config& config)
     : config_(config),
       animator_(new Animator(config, this)),
       binding_(this),
+      activity_running_(false),
+      have_surface_(false),
       weak_factory_(this) {
 }
 
 Engine::~Engine() {
 }
 
 base::WeakPtr<Engine> Engine::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
@@ skipping 39 matching lines @@
 }
 
 void Engine::ConnectToEngine(mojo::InterfaceRequest<SkyEngine> request) {
   binding_.Bind(request.Pass());
 }
 
 void Engine::OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) {
   config_.gpu_task_runner->PostTask(
       FROM_HERE, base::Bind(&GPUDelegate::OnAcceleratedWidgetAvailable,
                             config_.gpu_delegate, widget));
+  have_surface_ = true;
+  StartAnimatorIfPossible();
   if (sky_view_)
     ScheduleFrame();
 }
 
 void Engine::OnOutputSurfaceDestroyed() {
+  have_surface_ = false;
+  StopAnimator();
   config_.gpu_task_runner->PostTask(
       FROM_HERE,
       base::Bind(&GPUDelegate::OnOutputSurfaceDestroyed, config_.gpu_delegate));
 }
 
 void Engine::OnViewportMetricsChanged(ViewportMetricsPtr metrics) {
   physical_size_.SetSize(metrics->physical_width, metrics->physical_height);
 
   display_metrics_.physical_size = physical_size_;
   display_metrics_.device_pixel_ratio = metrics->device_pixel_ratio;
@@ skipping 52 matching lines @@
 void Engine::RunFromBundle(const mojo::String& path) {
   AssetUnpackerJob* unpacker = new AssetUnpackerJob(
       mojo::GetProxy(&root_bundle_), base::WorkerPool::GetTaskRunner(true));
   std::string path_str = path;
   unpacker->Unpack(Fetch(base::FilePath(path_str)));
   root_bundle_->GetAsStream(kSnapshotKey,
                             base::Bind(&Engine::RunFromSnapshotStream,
                                        weak_factory_.GetWeakPtr(), path_str));
 }
 
+void Engine::OnActivityPaused() {
+  activity_running_ = false;
+  StopAnimator();
+}
+
+void Engine::OnActivityResumed() {
+  activity_running_ = true;
+  StartAnimatorIfPossible();
+}
+
 void Engine::DidCreateIsolate(Dart_Isolate isolate) {
   Internals::Create(isolate,
                     CreateServiceProvider(config_.service_provider_context),
                     root_bundle_.Pass());
 }
 
+void Engine::StopAnimator() {
+  animator_->Stop();
+}
+
+void Engine::StartAnimatorIfPossible() {
+  if (activity_running_ && have_surface_)
+    animator_->Start();
+}
+
 void Engine::ScheduleFrame() {
   animator_->RequestFrame();
 }
 
 mojo::NavigatorHost* Engine::NavigatorHost() {
   return this;
 }
 
 void Engine::RequestNavigate(mojo::Target target,
                              mojo::URLRequestPtr request) {
   // Ignoring target for now.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&Engine::RunFromNetwork, GetWeakPtr(), request->url));
 }
 
 void Engine::DidNavigateLocally(const mojo::String& url) {
 }
 
 void Engine::RequestNavigateHistory(int32_t delta) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace shell
 }  // namespace sky