MidiService::TimestampToTimeDeltaDelay

Provide TimestampToTimeDeltaDelay as a static helper method of
MidiService, and use it to calculate a delay time for a timestamp
to post a delayed task.

Bug: 672793
Change-Id: I7307bb816c262073ceae557ad9345c451051d414
Reviewed-on: https://chromium-review.googlesource.com/656924
Commit-Queue: Takashi Toyoshima <toyoshim@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Cr-Commit-Position: refs/heads/master@{#501595}

media/midi/midi_manager_alsa.cc

@@ -321,19 +321,11 @@ void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32_t port_index,
                                            const std::vector<uint8_t>& data,
                                            double timestamp) {
-  base::TimeDelta delay;
-  if (timestamp != 0.0) {
-    base::TimeTicks time_to_send =
-        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
-                                timestamp * base::Time::kMicrosecondsPerSecond);
-    delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
-  }
-
   service()->task_service()->PostBoundDelayedTask(
       kSendTaskRunner,
       base::BindOnce(&MidiManagerAlsa::SendMidiData, base::Unretained(this),
                      client, port_index, data),
-      delay);
+      MidiService::TimestampToTimeDeltaDelay(timestamp));
 }
 
 MidiManagerAlsa::MidiPort::Id::Id() = default;

media/midi/midi_manager_win.cc

@@ -753,21 +753,10 @@ void MidiManagerWin::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
                                           const std::vector<uint8_t>& data,
                                           double timestamp) {
-  if (timestamp != 0.0) {
-    base::TimeTicks time =
-        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
-                                timestamp * base::Time::kMicrosecondsPerSecond);
-    base::TimeTicks now = base::TimeTicks::Now();
-    if (now < time) {
-      PostDelayedTask(
-          base::BindOnce(&MidiManagerWin::SendOnTaskRunner,
-                         base::Unretained(this), client, port_index, data),
-          time - now);
-      return;
-    }
-  }
-  PostTask(base::BindOnce(&MidiManagerWin::SendOnTaskRunner,
-                          base::Unretained(this), client, port_index, data));
+  PostDelayedTask(
+      base::BindOnce(&MidiManagerWin::SendOnTaskRunner, base::Unretained(this),
+                     client, port_index, data),
+      MidiService::TimestampToTimeDeltaDelay(timestamp));
 }
 
 void MidiManagerWin::OnDevicesChanged(

media/midi/midi_scheduler.cc

@@ -11,6 +11,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/midi/midi_manager.h"
+#include "media/midi/midi_service.h"
 
 namespace midi {
 
@@ -36,14 +37,9 @@ void MidiScheduler::PostSendDataTask(MidiManagerClient* client,
       base::BindOnce(&MidiScheduler::InvokeClosure, weak_factory_.GetWeakPtr(),
                      client, length, std::move(closure));
 
-  base::TimeDelta delay;
-  if (timestamp != 0.0) {
-    base::TimeTicks time_to_send =
-        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
-                                timestamp * base::Time::kMicrosecondsPerSecond);
-    delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
-  }
-  task_runner_->PostDelayedTask(FROM_HERE, std::move(weak_closure), delay);
+  task_runner_->PostDelayedTask(
+      FROM_HERE, std::move(weak_closure),
+      MidiService::TimestampToTimeDeltaDelay(timestamp));
 }
 
 void MidiScheduler::InvokeClosure(MidiManagerClient* client,

media/midi/midi_scheduler.h

@@ -19,6 +19,7 @@ namespace midi {
 class MidiManager;
 class MidiManagerClient;
 
+// DEPRECATED: Use TaskService for new code.
 // TODO(crbug.com/467442): Make tasks cancelable per client.
 class MIDI_EXPORT MidiScheduler final {
  public:

media/midi/midi_service.cc

@@ -31,6 +31,18 @@ std::unique_ptr<MidiManager> MidiService::ManagerFactory::Create(
   return std::unique_ptr<MidiManager>(MidiManager::Create(service));
 }
 
+// static
+base::TimeDelta MidiService::TimestampToTimeDeltaDelay(double timestamp) {
+  base::TimeDelta delay;
+  if (timestamp != 0.0) {
+    base::TimeTicks time_to_send =
+        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
+                                timestamp * base::Time::kMicrosecondsPerSecond);
+    delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
+  }
+  return delay;
+}
+
 MidiService::MidiService(void)
     : MidiService(std::make_unique<ManagerFactory>(),
                   IsDynamicInstantiationEnabled()) {}

media/midi/midi_service.h

@@ -15,6 +15,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
+#include "base/time/time.h"
 #include "media/midi/midi_export.h"
 #include "media/midi/midi_manager.h"
 
@@ -36,6 +37,9 @@ class MIDI_EXPORT MidiService final {
     DISALLOW_COPY_AND_ASSIGN(ManagerFactory);
   };
 
+  // Converts Web MIDI timestamp to base::TimeDelta dealy for PostDelayedTask.
+  static base::TimeDelta TimestampToTimeDeltaDelay(double timestamp);
+
   // Use the first constructor for production code.
   MidiService();
   // ManagerFactory can be specified in the constructor for testing.  If the