Convert double-as-a-time to base::TimeTicks around timestamps in WebMIDI

WebMIDI backend implementations have used double as a time type.
As base::TimeTicks is available in Blink now, it's better fit to use
as the timestamp.

Change-Id: Ide762f3a8dd503b3bd77eae9077f5ecde18e3796
Reviewed-on: https://chromium-review.googlesource.com/892726Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kent Tamura <tkent@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Takashi Toyoshima <toyoshim@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#533988}

content/browser/media/midi_host.cc

@@ -94,7 +94,7 @@ void MidiHost::OnStartSession() {
 
 void MidiHost::OnSendData(uint32_t port,
                           const std::vector<uint8_t>& data,
-                          double timestamp) {
+                          base::TimeTicks timestamp) {
   {
     base::AutoLock auto_lock(output_port_count_lock_);
     if (output_port_count_ <= port) {
@@ -172,7 +172,7 @@ void MidiHost::SetOutputPortState(uint32_t port, PortState state) {
 void MidiHost::ReceiveMidiData(uint32_t port,
                                const uint8_t* data,
                                size_t length,
-                               double timestamp) {
+                               base::TimeTicks timestamp) {
   TRACE_EVENT0("midi", "MidiHost::ReceiveMidiData");
 
   base::AutoLock auto_lock(messages_queues_lock_);

content/browser/media/midi_host.h

@@ -49,7 +49,7 @@ class CONTENT_EXPORT MidiHost : public BrowserMessageFilter,
   void ReceiveMidiData(uint32_t port,
                        const uint8_t* data,
                        size_t length,
-                       double timestamp) override;
+                       base::TimeTicks timestamp) override;
   void AccumulateMidiBytesSent(size_t n) override;
   void Detach() override;
 
@@ -59,7 +59,7 @@ class CONTENT_EXPORT MidiHost : public BrowserMessageFilter,
   // Data to be sent to a MIDI output port.
   void OnSendData(uint32_t port,
                   const std::vector<uint8_t>& data,
-                  double timestamp);
+                  base::TimeTicks timestamp);
 
   void OnEndSession();
 

content/browser/media/midi_host_unittest.cc

@@ -34,7 +34,7 @@ struct MidiEvent {
   MidiEvent(MidiEventType in_type,
             uint32_t in_port_index,
             const std::vector<uint8_t>& in_data,
-            double in_timestamp)
+            base::TimeTicks in_timestamp)
       : type(in_type),
         port_index(in_port_index),
         data(in_data),
@@ -43,7 +43,7 @@ struct MidiEvent {
   MidiEventType type;
   uint32_t port_index;
   std::vector<uint8_t> data;
-  double timestamp;
+  base::TimeTicks timestamp;
 };
 
 class FakeMidiManager : public midi::MidiManager {
@@ -59,7 +59,7 @@ class FakeMidiManager : public midi::MidiManager {
   void DispatchSendMidiData(midi::MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override {
+                            base::TimeTicks timestamp) override {
     events_.push_back(MidiEvent(DISPATCH_SEND_MIDI_DATA,
                                 port_index,
                                 data,
@@ -148,7 +148,7 @@ class MidiHostTest : public testing::Test {
 
   void OnSendData(uint32_t port) {
     std::unique_ptr<IPC::Message> message(
-        new MidiHostMsg_SendData(port, data_, 0.0));
+        new MidiHostMsg_SendData(port, data_, base::TimeTicks()));
     host_->OnMessageReceived(*message.get());
   }
 
@@ -164,7 +164,7 @@ class MidiHostTest : public testing::Test {
     EXPECT_EQ(DISPATCH_SEND_MIDI_DATA, manager->events_[at].type);
     EXPECT_EQ(port, manager->events_[at].port_index);
     EXPECT_EQ(data_, manager->events_[at].data);
-    EXPECT_EQ(0.0, manager->events_[at].timestamp);
+    EXPECT_EQ(base::TimeTicks(), manager->events_[at].timestamp);
   }
 
   void RunLoopUntilIdle() {

content/common/media/midi_messages.h

@@ -45,7 +45,7 @@ IPC_MESSAGE_CONTROL0(MidiHostMsg_StartSession)
 IPC_MESSAGE_CONTROL3(MidiHostMsg_SendData,
                      uint32_t /* port */,
                      std::vector<uint8_t> /* data */,
-                     double /* timestamp */)
+                     base::TimeTicks /* timestamp */)
 
 IPC_MESSAGE_CONTROL0(MidiHostMsg_EndSession)
 
@@ -70,7 +70,7 @@ IPC_MESSAGE_CONTROL1(MidiMsg_SessionStarted, midi::mojom::Result /* result */)
 IPC_MESSAGE_CONTROL3(MidiMsg_DataReceived,
                      uint32_t /* port */,
                      std::vector<uint8_t> /* data */,
-                     double /* timestamp */)
+                     base::TimeTicks /* timestamp */)
 
 IPC_MESSAGE_CONTROL1(MidiMsg_AcknowledgeSentData, uint32_t /* bytes sent */)
 

content/renderer/media/midi_message_filter.cc

@@ -75,7 +75,7 @@ void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) {
 void MidiMessageFilter::SendMidiData(uint32_t port,
                                      const uint8_t* data,
                                      size_t length,
-                                     double timestamp) {
+                                     base::TimeTicks timestamp) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if ((kMaxUnacknowledgedBytesSent - unacknowledged_bytes_sent_) < length) {
     // TODO(toyoshim): buffer up the data to send at a later time.
@@ -98,7 +98,7 @@ void MidiMessageFilter::StartSessionOnIOThread() {
 
 void MidiMessageFilter::SendMidiDataOnIOThread(uint32_t port,
                                                const std::vector<uint8_t>& data,
-                                               double timestamp) {
+                                               base::TimeTicks timestamp) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   Send(new MidiHostMsg_SendData(port, data, timestamp));
 }
@@ -189,7 +189,7 @@ void MidiMessageFilter::OnSetOutputPortState(uint32_t port, PortState state) {
 
 void MidiMessageFilter::OnDataReceived(uint32_t port,
                                        const std::vector<uint8_t>& data,
-                                       double timestamp) {
+                                       base::TimeTicks timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnDataReceived");
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   // Handle on the main JS thread.
@@ -260,7 +260,7 @@ void MidiMessageFilter::HandleAddOutputPort(midi::MidiPortInfo info) {
 
 void MidiMessageFilter::HandleDataReceived(uint32_t port,
                                            const std::vector<uint8_t>& data,
-                                           double timestamp) {
+                                           base::TimeTicks timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleDataReceived");
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(!data.empty());

content/renderer/media/midi_message_filter.h

@@ -47,7 +47,7 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   void SendMidiData(uint32_t port,
                     const uint8_t* data,
                     size_t length,
-                    double timestamp);
+                    base::TimeTicks timestamp);
 
   // IO task runner associated with this message filter.
   base::SingleThreadTaskRunner* io_task_runner() const {
@@ -62,7 +62,7 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
 
   void SendMidiDataOnIOThread(uint32_t port,
                               const std::vector<uint8_t>& data,
-                              double timestamp);
+                              base::TimeTicks timestamp);
 
   void EndSessionOnIOThread();
 
@@ -97,7 +97,7 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   // more messages.
   void OnDataReceived(uint32_t port,
                       const std::vector<uint8_t>& data,
-                      double timestamp);
+                      base::TimeTicks timestamp);
 
   // From time-to-time, the browser incrementally informs us of how many bytes
   // it has successfully sent. This is part of our throttling process to avoid
@@ -114,7 +114,7 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
 
   void HandleDataReceived(uint32_t port,
                           const std::vector<uint8_t>& data,
-                          double timestamp);
+                          base::TimeTicks timestamp);
 
   void HandleAckknowledgeSentData(size_t bytes_sent);
 

content/renderer/media/renderer_webmidiaccessor_impl.cc

@@ -29,7 +29,7 @@ void RendererWebMIDIAccessorImpl::StartSession() {
 void RendererWebMIDIAccessorImpl::SendMIDIData(unsigned port_index,
                                                const unsigned char* data,
                                                size_t length,
-                                               double timestamp) {
+                                               base::TimeTicks timestamp) {
   midi_message_filter()->SendMidiData(
       port_index,
       data,

content/renderer/media/renderer_webmidiaccessor_impl.h

@@ -28,7 +28,7 @@ class RendererWebMIDIAccessorImpl
   void SendMIDIData(unsigned port_index,
                     const unsigned char* data,
                     size_t length,
-                    double timestamp) override;
+                    base::TimeTicks timestamp) override;
 
  private:
   blink::WebMIDIAccessorClient* client_;

content/shell/test_runner/mock_web_midi_accessor.cc

@@ -61,7 +61,7 @@ void MockWebMIDIAccessor::StartSession() {
 void MockWebMIDIAccessor::SendMIDIData(unsigned port_index,
                                        const unsigned char* data,
                                        size_t length,
-                                       double timestamp) {
+                                       base::TimeTicks timestamp) {
   // Emulate a loopback device for testing. Make sure if an input port that has
   // the same index exists.
   if (port_index < next_input_port_index_)

content/shell/test_runner/mock_web_midi_accessor.h

@@ -31,7 +31,7 @@ class MockWebMIDIAccessor : public blink::WebMIDIAccessor {
   void SendMIDIData(unsigned port_index,
                     const unsigned char* data,
                     size_t length,
-                    double timestamp) override;
+                    base::TimeTicks timestamp) override;
 
  private:
   void addInputPort(midi::mojom::PortState state);

media/midi/midi_manager.cc

@@ -201,7 +201,7 @@ void MidiManager::AccumulateMidiBytesSent(MidiManagerClient* client, size_t n) {
 void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
                                        uint32_t port_index,
                                        const std::vector<uint8_t>& data,
-                                       double timestamp) {
+                                       base::TimeTicks timestamp) {
   NOTREACHED();
 }
 
@@ -263,7 +263,7 @@ void MidiManager::SetOutputPortState(uint32_t port_index, PortState state) {
 void MidiManager::ReceiveMidiData(uint32_t port_index,
                                   const uint8_t* data,
                                   size_t length,
-                                  double timestamp) {
+                                  base::TimeTicks timestamp) {
   base::AutoLock auto_lock(lock_);
   data_received_ = true;
 

media/midi/midi_manager.h

@@ -61,7 +61,7 @@ class MIDI_EXPORT MidiManagerClient {
   virtual void ReceiveMidiData(uint32_t port_index,
                                const uint8_t* data,
                                size_t length,
-                               double timestamp) = 0;
+                               base::TimeTicks timestamp) = 0;
 
   // AccumulateMidiBytesSent() is called to acknowledge when bytes have
   // successfully been sent to the hardware.
@@ -118,13 +118,13 @@ class MIDI_EXPORT MidiManager {
   // |port_index| represents the specific output port from output_ports().
   // |data| represents a series of bytes encoding one or more MIDI messages.
   // |length| is the number of bytes in |data|.
-  // |timestamp| is the time to send the data, in seconds. A value of 0
-  // means send "now" or as soon as possible.
-  // The default implementation is for unsupported platforms.
+  // |timestamp| is the time to send the data. A value of 0 means send "now" or
+  // as soon as possible. The default implementation is for unsupported
+  // platforms.
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32_t port_index,
                                     const std::vector<uint8_t>& data,
-                                    double timestamp);
+                                    base::TimeTicks timestamp);
 
  protected:
   friend class MidiManagerUsb;
@@ -158,20 +158,10 @@ class MIDI_EXPORT MidiManager {
   void SetOutputPortState(uint32_t port_index, mojom::PortState state);
 
   // Dispatches to all clients.
-  // TODO(toyoshim): Fix the mac implementation to use
-  // |ReceiveMidiData(..., base::TimeTicks)|.
   void ReceiveMidiData(uint32_t port_index,
                        const uint8_t* data,
                        size_t length,
-                       double timestamp);
-
-  void ReceiveMidiData(uint32_t port_index,
-                       const uint8_t* data,
-                       size_t length,
-                       base::TimeTicks time) {
-    ReceiveMidiData(port_index, data, length,
-                    (time - base::TimeTicks()).InSecondsF());
-  }
+                       base::TimeTicks time);
 
   size_t clients_size_for_testing() const { return clients_.size(); }
   size_t pending_clients_size_for_testing() const {

media/midi/midi_manager_alsa.cc

@@ -319,7 +319,7 @@ void MidiManagerAlsa::Finalize() {
 void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32_t port_index,
                                            const std::vector<uint8_t>& data,
-                                           double timestamp) {
+                                           base::TimeTicks timestamp) {
   service()->task_service()->PostBoundDelayedTask(
       kSendTaskRunner,
       base::BindOnce(&MidiManagerAlsa::SendMidiData, base::Unretained(this),
@@ -884,8 +884,7 @@ void MidiManagerAlsa::EventLoop() {
     if (pfd[0].revents & POLLIN) {
       // Read available incoming MIDI data.
       int remaining;
-      double timestamp =
-          (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+      base::TimeTicks timestamp = base::TimeTicks::Now();
       do {
         snd_seq_event_t* event;
         err = snd_seq_event_input(in_client_.get(), &event);
@@ -952,7 +951,7 @@ void MidiManagerAlsa::EventLoop() {
 }
 
 void MidiManagerAlsa::ProcessSingleEvent(snd_seq_event_t* event,
-                                         double timestamp) {
+                                         base::TimeTicks timestamp) {
   auto source_it =
       source_map_.find(AddrToInt(event->source.client, event->source.port));
   if (source_it != source_map_.end()) {

media/midi/midi_manager_alsa.h

@@ -36,7 +36,7 @@ class MIDI_EXPORT MidiManagerAlsa final : public MidiManager {
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override;
+                            base::TimeTicks timestamp) override;
 
  private:
   friend class MidiManagerAlsaTest;
@@ -374,7 +374,7 @@ class MIDI_EXPORT MidiManagerAlsa final : public MidiManager {
                     const std::vector<uint8_t>& data);
 
   void EventLoop();
-  void ProcessSingleEvent(snd_seq_event_t* event, double timestamp);
+  void ProcessSingleEvent(snd_seq_event_t* event, base::TimeTicks timestamp);
   void ProcessClientStartEvent(int client_id);
   void ProcessPortStartEvent(const snd_seq_addr_t& addr);
   void ProcessClientExitEvent(const snd_seq_addr_t& addr);

media/midi/midi_manager_android.cc

@@ -91,7 +91,7 @@ void MidiManagerAndroid::Finalize() {
 void MidiManagerAndroid::DispatchSendMidiData(MidiManagerClient* client,
                                               uint32_t port_index,
                                               const std::vector<uint8_t>& data,
-                                              double timestamp) {
+                                              base::TimeTicks timestamp) {
   if (port_index >= all_output_ports_.size()) {
     // |port_index| is provided by a renderer so we can't believe that it is
     // in the valid range.

media/midi/midi_manager_android.h

@@ -39,7 +39,7 @@ class MidiManagerAndroid final : public MidiManager,
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override;
+                            base::TimeTicks timestamp) override;
 
   // MidiInputPortAndroid::Delegate implementation.
   void OnReceivedData(MidiInputPortAndroid*,

media/midi/midi_manager_mac.cc

@@ -101,14 +101,13 @@ MidiPortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint) {
   return MidiPortInfo(id, manufacturer, name, version, state);
 }
 
-double MIDITimeStampToSeconds(MIDITimeStamp timestamp) {
+base::TimeTicks MIDITimeStampToTimeTicks(MIDITimeStamp timestamp) {
   UInt64 nanoseconds = AudioConvertHostTimeToNanos(timestamp);
-  return static_cast<double>(nanoseconds) / 1.0e9;
+  return base::TimeTicks() + base::TimeDelta::FromNanoseconds(nanoseconds);
 }
 
-MIDITimeStamp SecondsToMIDITimeStamp(double seconds) {
-  UInt64 nanos = UInt64(seconds * 1.0e9);
-  return AudioConvertNanosToHostTime(nanos);
+MIDITimeStamp TimeTicksToMIDITimeStamp(base::TimeTicks ticks) {
+  return AudioConvertNanosToHostTime(ticks.since_origin().InNanoseconds());
 }
 
 }  // namespace
@@ -147,7 +146,7 @@ void MidiManagerMac::Finalize() {
 void MidiManagerMac::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
                                           const std::vector<uint8_t>& data,
-                                          double timestamp) {
+                                          base::TimeTicks timestamp) {
   service()->task_service()->PostBoundTask(
       kClientTaskRunner,
       base::BindOnce(&MidiManagerMac::SendMidiData, base::Unretained(this),
@@ -298,10 +297,10 @@ void MidiManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
   const MIDIPacket* packet = &packet_list->packet[0];
   for (size_t i = 0u; i < packet_list->numPackets; i++) {
     // Each packet contains MIDI data for one or more messages (like note-on).
-    double timestamp_seconds = MIDITimeStampToSeconds(packet->timeStamp);
+    base::TimeTicks timestamp = MIDITimeStampToTimeTicks(packet->timeStamp);
 
     manager->ReceiveMidiData(port_index, packet->data, packet->length,
-                             timestamp_seconds);
+                             timestamp);
 
     packet = MIDIPacketNext(packet);
   }
@@ -310,13 +309,13 @@ void MidiManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
 void MidiManagerMac::SendMidiData(MidiManagerClient* client,
                                   uint32_t port_index,
                                   const std::vector<uint8_t>& data,
-                                  double timestamp) {
+                                  base::TimeTicks timestamp) {
   DCHECK(service()->task_service()->IsOnTaskRunner(kClientTaskRunner));
 
   // Lookup the destination based on the port index.
   if (static_cast<size_t>(port_index) >= destinations_.size())
     return;
-  MIDITimeStamp coremidi_timestamp = SecondsToMIDITimeStamp(timestamp);
+  MIDITimeStamp coremidi_timestamp = TimeTicksToMIDITimeStamp(timestamp);
   MIDIEndpointRef destination = destinations_[port_index];
 
   size_t send_size;

media/midi/midi_manager_mac.h

@@ -33,7 +33,7 @@ class MIDI_EXPORT MidiManagerMac final : public MidiManager {
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override;
+                            base::TimeTicks timestamp) override;
 
  private:
   // Initializes CoreMIDI on |client_thread_| asynchronously. Called from
@@ -57,7 +57,7 @@ class MIDI_EXPORT MidiManagerMac final : public MidiManager {
   void SendMidiData(MidiManagerClient* client,
                     uint32_t port_index,
                     const std::vector<uint8_t>& data,
-                    double timestamp);
+                    base::TimeTicks timestamp);
 
   // CoreMIDI client reference, should be protected by |midi_client_lock_|.
   MIDIClientRef midi_client_ = 0;

media/midi/midi_manager_mac_unittest.cc

@@ -68,7 +68,7 @@ class FakeMidiManagerClient : public MidiManagerClient {
   void ReceiveMidiData(uint32_t port_index,
                        const uint8_t* data,
                        size_t size,
-                       double timestamp) override {}
+                       base::TimeTicks timestamp) override {}
   void AccumulateMidiBytesSent(size_t size) override {}
   void Detach() override {}
 

media/midi/midi_manager_unittest.cc

@@ -52,7 +52,7 @@ class FakeMidiManager : public MidiManager {
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override {}
+                            base::TimeTicks timestamp) override {}
 
   // Utility functions for testing.
   void CallCompleteInitialization(Result result) {
@@ -131,7 +131,7 @@ class FakeMidiManagerClient : public MidiManagerClient {
   void ReceiveMidiData(uint32_t port_index,
                        const uint8_t* data,
                        size_t size,
-                       double timestamp) override {}
+                       base::TimeTicks timestamp) override {}
   void AccumulateMidiBytesSent(size_t size) override {}
   void Detach() override {}
 

media/midi/midi_manager_usb.cc

@@ -72,7 +72,7 @@ void MidiManagerUsb::Initialize(Callback callback) {
 void MidiManagerUsb::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
                                           const std::vector<uint8_t>& data,
-                                          double timestamp) {
+                                          base::TimeTicks timestamp) {
   if (port_index >= output_streams_.size()) {
     // |port_index| is provided by a renderer so we can't believe that it is
     // in the valid range.

media/midi/midi_manager_usb.h

@@ -45,7 +45,7 @@ class USB_MIDI_EXPORT MidiManagerUsb : public MidiManager,
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override;
+                            base::TimeTicks timestamp) override;
 
   // UsbMidiDeviceDelegate implementation.
   void ReceiveUsbMidiData(UsbMidiDevice* device,

media/midi/midi_manager_usb_unittest.cc

@@ -123,7 +123,7 @@ class FakeMidiManagerClient : public MidiManagerClient {
   void ReceiveMidiData(uint32_t port_index,
                        const uint8_t* data,
                        size_t size,
-                       double timestamp) override {
+                       base::TimeTicks timestamp) override {
     logger_->AddLog("MidiManagerClient::ReceiveMidiData ");
     logger_->AddLog(
         base::StringPrintf("usb:port_index = %d data =", port_index));
@@ -460,7 +460,8 @@ TEST_F(MidiManagerUsbTest, Send) {
   EXPECT_EQ(Result::OK, GetInitializationResult());
   ASSERT_EQ(2u, manager()->output_streams().size());
 
-  manager()->DispatchSendMidiData(client_.get(), 1, ToVector(data), 0);
+  manager()->DispatchSendMidiData(client_.get(), 1, ToVector(data),
+                                  base::TimeTicks());
   // Since UsbMidiDevice::Send is posted as a task, RunLoop should run to
   // invoke the task.
   base::RunLoop run_loop;
@@ -506,11 +507,13 @@ TEST_F(MidiManagerUsbTest, SendFromCompromizedRenderer) {
   EXPECT_EQ("UsbMidiDevice::GetDescriptors\n", logger_.TakeLog());
 
   // The specified port index is invalid. The manager must ignore the request.
-  manager()->DispatchSendMidiData(client_.get(), 99, ToVector(data), 0);
+  manager()->DispatchSendMidiData(client_.get(), 99, ToVector(data),
+                                  base::TimeTicks());
   EXPECT_EQ("", logger_.TakeLog());
 
   // The specified port index is invalid. The manager must ignore the request.
-  manager()->DispatchSendMidiData(client_.get(), 2, ToVector(data), 0);
+  manager()->DispatchSendMidiData(client_.get(), 2, ToVector(data),
+                                  base::TimeTicks());
   EXPECT_EQ("", logger_.TakeLog());
 }
 

media/midi/midi_manager_win.cc

@@ -751,7 +751,7 @@ void MidiManagerWin::Finalize() {
 void MidiManagerWin::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
                                           const std::vector<uint8_t>& data,
-                                          double timestamp) {
+                                          base::TimeTicks timestamp) {
   PostDelayedTask(
       base::BindOnce(&MidiManagerWin::SendOnTaskRunner, base::Unretained(this),
                      client, port_index, data),

media/midi/midi_manager_win.h

@@ -41,7 +41,7 @@ class MidiManagerWin final
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) override;
+                            base::TimeTicks timestamp) override;
 
   // base::SystemMonitor::DevicesChangedObserver overrides:
   void OnDevicesChanged(base::SystemMonitor::DeviceType device_type) override;

media/midi/midi_manager_winrt.cc

@@ -802,7 +802,7 @@ void MidiManagerWinrt::Finalize() {
 void MidiManagerWinrt::DispatchSendMidiData(MidiManagerClient* client,
                                             uint32_t port_index,
                                             const std::vector<uint8_t>& data,
-                                            double timestamp) {
+                                            base::TimeTicks timestamp) {
   base::TimeDelta delay = MidiService::TimestampToTimeDeltaDelay(timestamp);
   service()->task_service()->PostBoundDelayedTask(
       kComTaskRunner,

media/midi/midi_manager_winrt.h

@@ -28,7 +28,7 @@ class MIDI_EXPORT MidiManagerWinrt final : public MidiManager {
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp) final;
+                            base::TimeTicks timestamp) final;
 
  private:
   // Subclasses that access private/protected members of MidiManager.

media/midi/midi_service.cc

@@ -19,15 +19,11 @@ std::unique_ptr<MidiManager> MidiService::ManagerFactory::Create(
 }
 
 // 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;
+base::TimeDelta MidiService::TimestampToTimeDeltaDelay(
+    base::TimeTicks timestamp) {
+  if (timestamp.is_null())
+    return base::TimeDelta();
+  return std::max(timestamp - base::TimeTicks::Now(), base::TimeDelta());
 }
 
 MidiService::MidiService() : MidiService(std::make_unique<ManagerFactory>()) {}
@@ -95,7 +91,7 @@ bool MidiService::EndSession(MidiManagerClient* client) {
 void MidiService::DispatchSendMidiData(MidiManagerClient* client,
                                        uint32_t port_index,
                                        const std::vector<uint8_t>& data,
-                                       double timestamp) {
+                                       base::TimeTicks timestamp) {
   base::AutoLock lock(lock_);
 
   // MidiService needs to consider invalid DispatchSendMidiData calls without

media/midi/midi_service.h

@@ -37,8 +37,8 @@ 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);
+  // Converts Web MIDI timestamp to base::TimeDelta delay for PostDelayedTask.
+  static base::TimeDelta TimestampToTimeDeltaDelay(base::TimeTicks timestamp);
 
   MidiService();
   // Customized ManagerFactory can be specified in the constructor for testing.
@@ -60,7 +60,7 @@ class MIDI_EXPORT MidiService final {
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
-                            double timestamp);
+                            base::TimeTicks timestamp);
 
   // Returns a SingleThreadTaskRunner reference to serve MidiManager. Each
   // TaskRunner will be constructed on demand.

third_party/WebKit/Source/modules/webmidi/MIDIAccess.cpp

@@ -185,7 +185,7 @@ void MIDIAccess::DidSetOutputPortState(unsigned port_index, PortState state) {
 void MIDIAccess::DidReceiveMIDIData(unsigned port_index,
                                     const unsigned char* data,
                                     size_t length,
-                                    double time_stamp) {
+                                    TimeTicks time_stamp) {
   DCHECK(IsMainThread());
   if (port_index >= inputs_.size())
     return;
@@ -196,33 +196,12 @@ void MIDIAccess::DidReceiveMIDIData(unsigned port_index,
 void MIDIAccess::SendMIDIData(unsigned port_index,
                               const unsigned char* data,
                               size_t length,
-                              double time_stamp_in_milliseconds) {
-  // Do not continue sending when document is going to be closed.
-  Document* document = ToDocument(GetExecutionContext());
-  DCHECK(document);
-  DocumentLoader* loader = document->Loader();
-  if (!loader)
+                              TimeTicks time_stamp) {
+  DCHECK(!time_stamp.is_null());
+  if (!GetExecutionContext() || !data || !length ||
+      port_index >= outputs_.size())
     return;
 
-  if (!data || !length || port_index >= outputs_.size())
-    return;
-
-  // Convert from a time in milliseconds (a DOMHighResTimeStamp) according to
-  // the same time coordinate system as performance.now() into a time in seconds
-  // which is based on the time coordinate system of
-  // monotonicallyIncreasingTime().
-  double time_stamp;
-
-  if (!time_stamp_in_milliseconds) {
-    // We treat a value of 0 (which is the default value) as special, meaning
-    // "now".  We need to translate it exactly to 0 seconds.
-    time_stamp = 0;
-  } else {
-    double document_start_time =
-        TimeTicksInSeconds(loader->GetTiming().ReferenceMonotonicTime());
-    time_stamp = document_start_time + 0.001 * time_stamp_in_milliseconds;
-  }
-
   accessor_->SendMIDIData(port_index, data, length, time_stamp);
 }
 

third_party/WebKit/Source/modules/webmidi/MIDIAccess.h

@@ -115,14 +115,14 @@ class MIDIAccess final : public EventTargetWithInlineData,
   void DidReceiveMIDIData(unsigned port_index,
                           const unsigned char* data,
                           size_t length,
-                          double time_stamp) override;
+                          TimeTicks time_stamp) override;
 
   // |timeStampInMilliseconds| is in the same time coordinate system as
   // performance.now().
   void SendMIDIData(unsigned port_index,
                     const unsigned char* data,
                     size_t length,
-                    double time_stamp_in_milliseconds);
+                    TimeTicks time_stamp);
 
   // Eager finalization needed to promptly release m_accessor. Otherwise
   // its client back reference could end up being unsafely used during

third_party/WebKit/Source/modules/webmidi/MIDIAccessInitializer.h

@@ -82,7 +82,7 @@ class MODULES_EXPORT MIDIAccessInitializer : public ScriptPromiseResolver,
   void DidReceiveMIDIData(unsigned port_index,
                           const unsigned char* data,
                           size_t length,
-                          double time_stamp) override {}
+                          TimeTicks time_stamp) override {}
 
  private:
   MIDIAccessInitializer(ScriptState*, const MIDIOptions&);

third_party/WebKit/Source/modules/webmidi/MIDIAccessor.cpp

@@ -64,7 +64,7 @@ void MIDIAccessor::StartSession() {
 void MIDIAccessor::SendMIDIData(unsigned port_index,
                                 const unsigned char* data,
                                 size_t length,
-                                double time_stamp) {
+                                base::TimeTicks time_stamp) {
   accessor_->SendMIDIData(port_index, data, length, time_stamp);
 }
 
@@ -99,7 +99,7 @@ void MIDIAccessor::DidStartSession(Result result) {
 void MIDIAccessor::DidReceiveMIDIData(unsigned port_index,
                                       const unsigned char* data,
                                       size_t length,
-                                      double time_stamp) {
+                                      base::TimeTicks time_stamp) {
   client_->DidReceiveMIDIData(port_index, data, length, time_stamp);
 }
 

third_party/WebKit/Source/modules/webmidi/MIDIAccessor.h

@@ -32,6 +32,7 @@
 #define MIDIAccessor_h
 
 #include <memory>
+#include "base/time/time.h"
 #include "media/midi/midi_service.mojom-blink.h"
 #include "platform/wtf/Allocator.h"
 #include "public/platform/modules/webmidi/WebMIDIAccessor.h"
@@ -53,7 +54,7 @@ class MIDIAccessor final : public WebMIDIAccessorClient {
   void SendMIDIData(unsigned port_index,
                     const unsigned char* data,
                     size_t length,
-                    double time_stamp);
+                    base::TimeTicks time_stamp);
   // MIDIAccessInitializer and MIDIAccess are both MIDIAccessClient.
   // MIDIAccessInitializer is the first client and MIDIAccess takes over it
   // once the initialization successfully finishes.
@@ -78,7 +79,7 @@ class MIDIAccessor final : public WebMIDIAccessorClient {
   void DidReceiveMIDIData(unsigned port_index,
                           const unsigned char* data,
                           size_t length,
-                          double time_stamp) override;
+                          base::TimeTicks time_stamp) override;
 
  private:
   explicit MIDIAccessor(MIDIAccessorClient*);

third_party/WebKit/Source/modules/webmidi/MIDIAccessorClient.h

@@ -31,6 +31,7 @@
 #ifndef MIDIAccessorClient_h
 #define MIDIAccessorClient_h
 
+#include "base/time/time.h"
 #include "media/midi/midi_service.mojom-blink.h"
 #include "modules/webmidi/MIDIAccessor.h"
 #include "platform/wtf/Forward.h"
@@ -58,7 +59,7 @@ class MIDIAccessorClient {
   virtual void DidReceiveMIDIData(unsigned port_index,
                                   const unsigned char* data,
                                   size_t length,
-                                  double time_stamp) = 0;
+                                  base::TimeTicks time_stamp) = 0;
 };
 
 }  // namespace blink

third_party/WebKit/Source/modules/webmidi/MIDIInput.cpp

@@ -83,7 +83,7 @@ void MIDIInput::AddedEventListener(
 void MIDIInput::DidReceiveMIDIData(unsigned port_index,
                                    const unsigned char* data,
                                    size_t length,
-                                   double time_stamp) {
+                                   base::TimeTicks time_stamp) {
   DCHECK(IsMainThread());
 
   if (!length)

third_party/WebKit/Source/modules/webmidi/MIDIInput.h

@@ -60,12 +60,10 @@ class MIDIInput final : public MIDIPort {
     return EventTargetNames::MIDIInput;
   }
 
-  // |timeStamp| is a DOMHighResTimeStamp in the time coordinate system of
-  // performance.now().
   void DidReceiveMIDIData(unsigned port_index,
                           const unsigned char* data,
                           size_t length,
-                          double time_stamp);
+                          base::TimeTicks time_stamp);
 
   virtual void Trace(blink::Visitor*);
 

third_party/WebKit/Source/modules/webmidi/MIDIMessageEvent.h

@@ -31,6 +31,7 @@
 #ifndef MIDIMessageEvent_h
 #define MIDIMessageEvent_h
 
+#include "base/time/time.h"
 #include "core/typed_arrays/DOMTypedArray.h"
 #include "modules/EventModules.h"
 
@@ -42,7 +43,8 @@ class MIDIMessageEvent final : public Event {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static MIDIMessageEvent* Create(double time_stamp, DOMUint8Array* data) {
+  static MIDIMessageEvent* Create(base::TimeTicks time_stamp,
+                                  DOMUint8Array* data) {
     return new MIDIMessageEvent(time_stamp, data);
   }
 
@@ -63,11 +65,8 @@ class MIDIMessageEvent final : public Event {
   }
 
  private:
-  MIDIMessageEvent(double time_stamp, DOMUint8Array* data)
-      : Event(EventTypeNames::midimessage,
-              true,
-              false,
-              TimeTicks() + TimeDelta::FromSecondsD(time_stamp)),
+  MIDIMessageEvent(base::TimeTicks time_stamp, DOMUint8Array* data)
+      : Event(EventTypeNames::midimessage, true, false, time_stamp),
         data_(data) {}
 
   MIDIMessageEvent(const AtomicString& type,

third_party/WebKit/Source/modules/webmidi/MIDIOutput.cpp

@@ -66,7 +66,7 @@ DOMUint8Array* ConvertUnsignedDataToUint8Array(
   return array;
 }
 
-double GetTimeOrigin(ExecutionContext* context) {
+base::TimeTicks GetTimeOrigin(ExecutionContext* context) {
   DCHECK(context);
   PerformanceBase* performance = nullptr;
   if (LocalDOMWindow* window = context->ExecutingWindow()) {
@@ -78,7 +78,8 @@ double GetTimeOrigin(ExecutionContext* context) {
   }
 
   DCHECK(performance);
-  return performance->timeOrigin();
+  return base::TimeTicks() +
+         TimeDelta::FromMillisecondsD(performance->timeOrigin());
 }
 
 class MessageValidator {
@@ -257,11 +258,12 @@ void MIDIOutput::send(NotShared<DOMUint8Array> array,
   if (!context)
     return;
 
-  double timestamp;
+  base::TimeTicks timestamp;
   if (timestamp_in_milliseconds == 0.0) {
-    timestamp = CurrentTimeTicksInMilliseconds();
+    timestamp = base::TimeTicks::Now();
   } else {
-    timestamp = GetTimeOrigin(context) + timestamp_in_milliseconds;
+    timestamp = GetTimeOrigin(context) +
+                base::TimeDelta::FromMillisecondsD(timestamp_in_milliseconds);
   }
   SendInternal(array.View(), timestamp, exception_state);
 }
@@ -289,7 +291,7 @@ void MIDIOutput::send(NotShared<DOMUint8Array> data,
     return;
 
   DCHECK(data);
-  SendInternal(data.View(), CurrentTimeTicksInMilliseconds(), exception_state);
+  SendInternal(data.View(), base::TimeTicks::Now(), exception_state);
 }
 
 void MIDIOutput::send(Vector<unsigned> unsigned_data,
@@ -304,7 +306,7 @@ void MIDIOutput::send(Vector<unsigned> unsigned_data,
     return;
   }
 
-  SendInternal(array, CurrentTimeTicksInMilliseconds(), exception_state);
+  SendInternal(array, base::TimeTicks::Now(), exception_state);
 }
 
 void MIDIOutput::DidOpen(bool opened) {
@@ -327,11 +329,11 @@ void MIDIOutput::Trace(blink::Visitor* visitor) {
 }
 
 void MIDIOutput::SendInternal(DOMUint8Array* array,
-                              double platform_timestamp,
+                              base::TimeTicks timestamp,
                               ExceptionState& exception_state) {
   DCHECK(GetExecutionContext());
   DCHECK(array);
-  DCHECK_NE(0.0, platform_timestamp);
+  DCHECK(!timestamp.is_null());
   UseCounter::Count(GetExecutionContext(), WebFeature::kMIDIOutputSend);
 
   // Implicit open. It does nothing if the port is already opened.
@@ -343,10 +345,10 @@ void MIDIOutput::SendInternal(DOMUint8Array* array,
     return;
 
   if (IsOpening()) {
-    pending_data_.emplace_back(array, platform_timestamp);
+    pending_data_.emplace_back(array, timestamp);
   } else {
     midiAccess()->SendMIDIData(port_index_, array->Data(), array->length(),
-                               platform_timestamp);
+                               timestamp);
   }
 }
 

third_party/WebKit/Source/modules/webmidi/MIDIOutput.h

@@ -32,6 +32,7 @@
 #define MIDIOutput_h
 
 #include <utility>
+#include "base/time/time.h"
 #include "core/typed_arrays/ArrayBufferViewHelpers.h"
 #include "core/typed_arrays/DOMTypedArray.h"
 #include "modules/webmidi/MIDIPort.h"
@@ -74,10 +75,10 @@ class MIDIOutput final : public MIDIPort {
              midi::mojom::PortState);
 
   void DidOpen(bool opened) override;
-  void SendInternal(DOMUint8Array*, double platform_timestamp, ExceptionState&);
+  void SendInternal(DOMUint8Array*, base::TimeTicks timestamp, ExceptionState&);
 
   unsigned port_index_;
-  HeapDeque<std::pair<Member<DOMUint8Array>, double>> pending_data_;
+  HeapDeque<std::pair<Member<DOMUint8Array>, base::TimeTicks>> pending_data_;
 };
 
 }  // namespace blink

third_party/WebKit/public/platform/modules/webmidi/WebMIDIAccessor.h

@@ -31,6 +31,7 @@
 #ifndef WebMIDIAccessor_h
 #define WebMIDIAccessor_h
 
+#include "base/time/time.h"
 #include "public/platform/WebString.h"
 
 namespace blink {
@@ -45,7 +46,7 @@ class WebMIDIAccessor {
   virtual void SendMIDIData(unsigned port_index,
                             const unsigned char* data,
                             size_t length,
-                            double time_stamp) {}
+                            base::TimeTicks time_stamp) {}
   virtual void Clear(unsigned port_index) {}
   virtual void Close(unsigned port_index) {}
 };

third_party/WebKit/public/platform/modules/webmidi/WebMIDIAccessorClient.h

@@ -63,7 +63,7 @@ class WebMIDIAccessorClient {
   virtual void DidReceiveMIDIData(unsigned port_index,
                                   const unsigned char* data,
                                   size_t length,
-                                  double time_stamp) = 0;
+                                  base::TimeTicks time_stamp) = 0;
 
  protected:
   virtual ~WebMIDIAccessorClient() = default;