Remove calls to deprecated MessageLoop methods on Windows and Linux.

media/midi/midi_manager_alsa.cc

 // Copyright 2014 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_alsa.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "crypto/sha2.h"
 #include "media/midi/midi_port_info.h"
 
 namespace media {
 namespace midi {
 
 namespace {
@@ skipping 245 matching lines @@
   EnumerateAlsaPorts();
 
   // Generate hotplug events for existing udev devices. This must be done
   // after udev_monitor_enable_receiving() is called. See the algorithm
   // at http://www.signal11.us/oss/udev/.
   EnumerateUdevCards();
 
   // Start processing events. Don't do this before enumeration of both
   // ALSA and udev.
   event_thread_.Start();
-  event_thread_.message_loop()->PostTask(
+  event_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::ScheduleEventLoop, base::Unretained(this)));
   send_thread_.Start();
 
   CompleteInitialization(Result::OK);
 }
 
 void MidiManagerAlsa::Finalize() {
   base::AutoLock lock(lazy_init_member_lock_);
   DCHECK(initialization_thread_checker_->CalledOnValidThread());
@@ skipping 29 matching lines @@
                                            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());
   }
 
-  send_thread_.message_loop()->PostDelayedTask(
+  send_thread_.task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&MidiManagerAlsa::SendMidiData,
                             base::Unretained(this), port_index, data),
       delay);
 
   // Acknowledge send.
-  send_thread_.message_loop()->PostTask(
+  send_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&MidiManagerAlsa::AccumulateMidiBytesSent,
                             base::Unretained(this), client, data.size()));
 }
 
 MidiManagerAlsa::MidiPort::Id::Id() = default;
 
 MidiManagerAlsa::MidiPort::Id::Id(const std::string& bus,
                                   const std::string& vendor_id,
                                   const std::string& model_id,
                                   const std::string& usb_interface_num,
@@ skipping 523 matching lines @@
         snd_seq_ev_set_subs(&event);
         snd_seq_ev_set_direct(&event);
         snd_seq_event_output_direct(out_client_.get(), &event);
       }
     }
   }
   snd_midi_event_free(encoder);
 }
 
 void MidiManagerAlsa::ScheduleEventLoop() {
-  event_thread_.message_loop()->PostTask(
+  event_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
 }
 
 void MidiManagerAlsa::EventLoop() {
   bool loop_again = true;
 
   struct pollfd pfd[2];
   snd_seq_poll_descriptors(in_client_.get(), &pfd[0], 1, POLLIN);
   pfd[1].fd = device::udev_monitor_get_fd(udev_monitor_.get());
@@ skipping 497 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media