content/blimp: Set up hooks for enabling LTHRemote in the renderer.

blimp/engine/renderer/scheduler.cc

+// Copyright 2016 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/engine/renderer/scheduler.h"
+
+#include "base/logging.h"
+#include "blimp/engine/renderer/scheduler_client.h"
+
+namespace blimp {
+namespace engine {
+namespace {
+// This is the temporary frame delay to keep pages which make animation requests
+// but don't mutate the state on the engine from running main frames
+// back-to-back. We need smarter throttling of engine updates. See
+// crbug.com/597829.
+const base::TimeDelta kDefaultFrameDelay =

[Wez, 2016/10/13 16:53:52]

Is TimeDelta POD?  I thought it had a ctor/dtor, so won't this result in
ini/fini?

[Khushal, 2016/10/13 18:47:27]

Its POD, doesn't have a dtor.

Found an example of similar use as well,
https://cs.chromium.org/chromium/src/cc/scheduler/compositor_timing_history.c...

[Wez, 2016/10/18 01:49:42]

Oh, OK; I'm surprised that assigning it a value using FromMilliseconds doesn't
trigger generation of _init code, though.

[Wez, 2016/10/19 22:01:34]

Aha, looks like From*() are all constexpr!

+    base::TimeDelta::FromMilliseconds(30);
+}  // namespace
+
+Scheduler::Scheduler(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                     SchedulerClient* client)
+    : Scheduler(kDefaultFrameDelay, std::move(task_runner), client) {}
+
+Scheduler::Scheduler(base::TimeDelta frame_delay,
+                     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                     SchedulerClient* client)
+    : next_frame_time_(base::TimeTicks::Now()),
+      frame_delay_(frame_delay),
+      client_(client),
+      weak_ptr_factory_(this) {
+  DCHECK(client_);
+  frame_tick_timer_.SetTaskRunner(std::move(task_runner));
+}
+
+Scheduler::~Scheduler() = default;
+
+void Scheduler::SetNeedsMainFrame() {
+  if (needs_main_frame_)
+    return;
+
+  needs_main_frame_ = true;
+  ScheduleMainFrameIfNecessary();
+}
+
+void Scheduler::DidSendFrameUpdateToClient() {
+  DCHECK(!frame_ack_pending_) << "We can have only frame update in flight";
+
+  frame_ack_pending_ = true;
+  ScheduleMainFrameIfNecessary();
+}
+
+void Scheduler::DidReceiveFrameUpdateAck() {
+  DCHECK(frame_ack_pending_);
+
+  frame_ack_pending_ = false;
+  ScheduleMainFrameIfNecessary();
+}
+
+void Scheduler::ScheduleMainFrameIfNecessary() {
+  // If we can't produce main frame updates right now, don't schedule a task.
+  if (!CanProduceMainFrames()) {
+    return;
+  }
+
+  // If a task has already been scheduled, we don't need to schedule again.
+  if (frame_tick_timer_.IsRunning())
+    return;
+
+  base::TimeDelta delay = next_frame_time_ - base::TimeTicks::Now();
+  frame_tick_timer_.Start(
+      FROM_HERE, delay,
+      base::Bind(&Scheduler::StartMainFrame, weak_ptr_factory_.GetWeakPtr()));

[Wez, 2016/10/13 16:53:52]

Take a WeakPtr at construction time, rather than calling GetWeakPtr on each
Bind.  However, why do you need a WeakPtr at all?  Doesn't this class own the
OneShotTimer?  So when this is deleted, so is the timer?

What is the threading property for this class?

[Khushal, 2016/10/13 18:47:27]

The class is created/destroyed and lives on the same thread. You're right, I
don't here. Removed.

+}
+
+bool Scheduler::CanProduceMainFrames() const {
+  return needs_main_frame_ && !frame_ack_pending_;
+}
+
+void Scheduler::StartMainFrame() {
+  DCHECK(needs_main_frame_);
+
+  // If an update was sent to the client since this request, we can not start
+  // another frame. Early out here, we'll come back when an Ack is received from
+  // the client.
+  if (frame_ack_pending_)
+    return;
+
+  needs_main_frame_ = false;
+  next_frame_time_ = base::TimeTicks::Now() + frame_delay_;
+  client_->StartMainFrameUpdate();
+}
+
+}  // namespace engine
+}  // namespace blimp