Remove calls to deprecated MessageLoop methods on Windows and Linux.

media/midi/midi_manager_win.cc

 // Copyright 2013 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 "media/midi/midi_manager_win.h"
 
 #include <windows.h>
 #include <ks.h>
 #include <ksmedia.h>
 #include <mmreg.h>
@@ skipping 12 matching lines @@
 
 #include <algorithm>
 #include <functional>
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "base/win/message_window.h"
 #include "device/usb/usb_ids.h"
@@ skipping 451 matching lines @@
     sender_thread_.Start();
     task_thread_.Start();
 
     // Start monitoring device changes. This should start before the
     // following UpdateDeviceList() call not to miss the event happening
     // between the call and the observer registration.
     base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
 
     UpdateDeviceList();
 
-    task_thread_.message_loop()->PostTask(
+    task_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::CompleteInitializationOnTaskThread,
                    base::Unretained(this), Result::OK));
   }
 
   void SendMidiDataAsync(uint32_t port_number,
                          const std::vector<uint8_t>& data,
                          base::TimeTicks time) final {
     if (destructor_started) {
       LOG(ERROR) << "ThreadSafeSendData failed because MidiServiceWinImpl is "
                     "being destructed.  port: " << port_number;
       return;
     }
     auto state = GetOutputDeviceFromPort(port_number);
     if (!state) {
       LOG(ERROR) << "ThreadSafeSendData failed due to an invalid port number. "
                  << "port: " << port_number;
       return;
     }
     if (state->closed) {
       LOG(ERROR)
           << "ThreadSafeSendData failed because target port is already closed."
           << "port: " << port_number;
       return;
     }
     const auto now = base::TimeTicks::Now();
     if (now < time) {
-      sender_thread_.message_loop()->PostDelayedTask(
+      sender_thread_.task_runner()->PostDelayedTask(
           FROM_HERE, base::Bind(&MidiServiceWinImpl::SendOnSenderThread,
                                 base::Unretained(this), port_number,
                                 state->port_age, data, time),
           time - now);
     } else {
-      sender_thread_.message_loop()->PostTask(
+      sender_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&MidiServiceWinImpl::SendOnSenderThread,
                                 base::Unretained(this), port_number,
                                 state->port_age, data, time));
     }
   }
 
   // base::SystemMonitor::DevicesChangedObserver overrides:
   void OnDevicesChanged(base::SystemMonitor::DeviceType device_type) final {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (destructor_started)
@@ skipping 29 matching lines @@
 
   scoped_refptr<MidiOutputDeviceState> GetOutputDeviceFromPort(
       uint32_t port_number) {
     base::AutoLock auto_lock(output_ports_lock_);
     if (output_ports_.size() <= port_number)
       return nullptr;
     return output_ports_[port_number];
   }
 
   void UpdateDeviceList() {
-    task_thread_.message_loop()->PostTask(
+    task_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&MidiServiceWinImpl::UpdateDeviceListOnTaskThread,
                               base::Unretained(this)));
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // Callbacks on the OS multimedia thread.
   /////////////////////////////////////////////////////////////////////////////
 
   static void CALLBACK
   OnMidiInEventOnMainlyMultimediaThread(HMIDIIN midi_in_handle,
@@ skipping 59 matching lines @@
       }
       input_ports_[port_number] = state;
 
       input_ports_ages_[port_number] += 1;
       input_device_map_[input_ports_[port_number]->midi_handle] =
           input_ports_[port_number];
       input_ports_[port_number]->port_index = port_number;
       input_ports_[port_number]->port_age = input_ports_ages_[port_number];
     }
     // Several initial startup tasks cannot be done in MIM_OPEN handler.
-    task_thread_.message_loop()->PostTask(
+    task_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&MidiServiceWinImpl::StartInputDeviceOnTaskThread,
                               base::Unretained(this), midi_in_handle));
     if (add_new_port) {
       const MidiPortInfo port_info(
           // TODO(toyoshim): Use a hash ID insted crbug.com/467448
           base::IntToString(static_cast<int>(port_number)),
           GetManufacturerName(state_device_info),
           base::WideToUTF8(state_device_info.product_name),
           MmversionToString(state_device_info.driver_version),
           MIDI_PORT_OPENED);
-      task_thread_.message_loop()->PostTask(
+      task_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&MidiServiceWinImpl::AddInputPortOnTaskThread,
                                 base::Unretained(this), port_info));
     } else {
-      task_thread_.message_loop()->PostTask(
+      task_thread_.task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&MidiServiceWinImpl::SetInputPortStateOnTaskThread,
                      base::Unretained(this), port_number,
                      MidiPortState::MIDI_PORT_CONNECTED));
     }
   }
 
   void OnMidiInDataOnMultimediaThread(HMIDIIN midi_in_handle,
                                       DWORD_PTR param1,
                                       DWORD_PTR param2) {
     auto state = GetInputDeviceFromHandle(midi_in_handle);
     if (!state)
       return;
     const uint8_t status_byte = static_cast<uint8_t>(param1 & 0xff);
     const uint8_t first_data_byte = static_cast<uint8_t>((param1 >> 8) & 0xff);
     const uint8_t second_data_byte =
         static_cast<uint8_t>((param1 >> 16) & 0xff);
     const DWORD elapsed_ms = param2;
     const size_t len = GetMidiMessageLength(status_byte);
     const uint8_t kData[] = {status_byte, first_data_byte, second_data_byte};
     std::vector<uint8_t> data;
     data.assign(kData, kData + len);
     DCHECK_LE(len, arraysize(kData));
     // MIM_DATA/MIM_LONGDATA message treats the time when midiInStart() is
     // called as the origin of |elapsed_ms|.
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757284.aspx
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757286.aspx
     const base::TimeTicks event_time =
         state->start_time + base::TimeDelta::FromMilliseconds(elapsed_ms);
-    task_thread_.message_loop()->PostTask(
+    task_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&MidiServiceWinImpl::ReceiveMidiDataOnTaskThread,
                               base::Unretained(this), state->port_index, data,
                               event_time));
   }
 
   void OnMidiInLongDataOnMultimediaThread(HMIDIIN midi_in_handle,
                                           DWORD_PTR param1,
                                           DWORD_PTR param2) {
     auto state = GetInputDeviceFromHandle(midi_in_handle);
     if (!state)
@@ skipping 16 matching lines @@
     if (header->dwBytesRecorded > 0) {
       const uint8_t* src = reinterpret_cast<const uint8_t*>(header->lpData);
       std::vector<uint8_t> data;
       data.assign(src, src + header->dwBytesRecorded);
       // MIM_DATA/MIM_LONGDATA message treats the time when midiInStart() is
       // called as the origin of |elapsed_ms|.
       // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757284.aspx
       // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757286.aspx
       const base::TimeTicks event_time =
           state->start_time + base::TimeDelta::FromMilliseconds(elapsed_ms);
-      task_thread_.message_loop()->PostTask(
+      task_thread_.task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&MidiServiceWinImpl::ReceiveMidiDataOnTaskThread,
                      base::Unretained(this), state->port_index, data,
                      event_time));
     }
     result = midiInAddBuffer(state->midi_handle, header, sizeof(*header));
     DLOG_IF(ERROR, result != MMSYSERR_NOERROR)
         << "Failed to attach input buffer: " << GetInErrorMessage(result)
         << "port number:" << state->port_index;
   }
 
   void OnMidiInCloseOnMultimediaThread(HMIDIIN midi_in_handle) {
     auto state = GetInputDeviceFromHandle(midi_in_handle);
     if (!state)
       return;
     const uint32_t port_number = state->port_index;
     const auto device_info(state->device_info);
     {
       base::AutoLock auto_lock(input_ports_lock_);
       input_device_map_.erase(state->midi_handle);
       input_ports_[port_number] = nullptr;
       input_ports_ages_[port_number] += 1;
       unused_input_ports_[device_info].push(port_number);
     }
-    task_thread_.message_loop()->PostTask(
+    task_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::SetInputPortStateOnTaskThread,
                    base::Unretained(this), port_number,
                    MIDI_PORT_DISCONNECTED));
   }
 
   static void CALLBACK
   OnMidiOutEventOnMainlyMultimediaThread(HMIDIOUT midi_out_handle,
                                          UINT message,
                                          DWORD_PTR instance,
@@ skipping 61 matching lines @@
       output_ports_[port_number]->port_age = output_ports_ages_[port_number];
     }
     if (add_new_port) {
       const MidiPortInfo port_info(
           // TODO(toyoshim): Use a hash ID insted. crbug.com/467448
           base::IntToString(static_cast<int>(port_number)),
           GetManufacturerName(state_device_info),
           base::WideToUTF8(state_device_info.product_name),
           MmversionToString(state_device_info.driver_version),
           MIDI_PORT_OPENED);
-      task_thread_.message_loop()->PostTask(
+      task_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&MidiServiceWinImpl::AddOutputPortOnTaskThread,
                                 base::Unretained(this), port_info));
     } else {
-      task_thread_.message_loop()->PostTask(
+      task_thread_.task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&MidiServiceWinImpl::SetOutputPortStateOnTaskThread,
                      base::Unretained(this), port_number, MIDI_PORT_CONNECTED));
     }
   }
 
   void OnMidiOutDoneOnMultimediaThread(HMIDIOUT midi_out_handle,
                                        DWORD_PTR param1) {
     auto state = GetOutputDeviceFromHandle(midi_out_handle);
     if (!state)
@@ skipping 16 matching lines @@
     const uint32_t port_number = state->port_index;
     const auto device_info(state->device_info);
     {
       base::AutoLock auto_lock(output_ports_lock_);
       output_device_map_.erase(state->midi_handle);
       output_ports_[port_number] = nullptr;
       output_ports_ages_[port_number] += 1;
       unused_output_ports_[device_info].push(port_number);
       state->closed = true;
     }
-    task_thread_.message_loop()->PostTask(
+    task_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::SetOutputPortStateOnTaskThread,
                    base::Unretained(this), port_number,
                    MIDI_PORT_DISCONNECTED));
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // Callbacks on the sender thread.
   /////////////////////////////////////////////////////////////////////////////
 
@@ skipping 277 matching lines @@
                                        base::TimeTicks time) {
   ReceiveMidiData(port_index, &data[0], data.size(), time);
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerWin();
 }
 
 }  // namespace midi
 }  // namespace media