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/892726
Reviewed-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;