Move safe_strerror to posix directory and the base namespace

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 <poll.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
-#include "base/safe_strerror_posix.h"
+#include "base/posix/safe_strerror.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 226 matching lines @@
   udev_monitor_.reset(
       device::udev_monitor_new_from_netlink(udev_.get(), kUdev));
   if (!udev_monitor_.get()) {
     VLOG(1) << "udev_monitor_new_from_netlink fails";
     return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
   }
   err = device::udev_monitor_filter_add_match_subsystem_devtype(
       udev_monitor_.get(), kUdevSubsystemSound, nullptr);
   if (err != 0) {
     VLOG(1) << "udev_monitor_add_match_subsystem fails: "
-            << safe_strerror(-err);
+            << base::safe_strerror(-err);
     return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
   }
   err = device::udev_monitor_enable_receiving(udev_monitor_.get());
   if (err != 0) {
-    VLOG(1) << "udev_monitor_enable_receiving fails: " << safe_strerror(-err);
+    VLOG(1) << "udev_monitor_enable_receiving fails: "
+            << base::safe_strerror(-err);
     return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
   }
 
   // Generate hotplug events for existing udev devices.
   EnumerateUdevCards();
 
   // Start processing events.
   event_thread_.Start();
   event_thread_.message_loop()->PostTask(
       FROM_HERE,
@@ skipping 587 matching lines @@
 void MidiManagerAlsa::EventLoop() {
   bool loop_again = true;
 
   struct pollfd pfd[2];
   snd_seq_poll_descriptors(in_client_, &pfd[0], 1, POLLIN);
   pfd[1].fd = device::udev_monitor_get_fd(udev_monitor_.get());
   pfd[1].events = POLLIN;
 
   int err = HANDLE_EINTR(poll(pfd, arraysize(pfd), -1));
   if (err < 0) {
-    VLOG(1) << "poll fails: " << safe_strerror(errno);
+    VLOG(1) << "poll fails: " << base::safe_strerror(errno);
     loop_again = false;
   } else {
     if (pfd[0].revents & POLLIN) {
       // Read available incoming MIDI data.
       int remaining;
       double timestamp =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       do {
         snd_seq_event_t* event;
         err = snd_seq_event_input(in_client_, &event);
@@ skipping 373 matching lines @@
       device::udev_enumerate_new(udev_.get()));
   if (!enumerate.get()) {
     VLOG(1) << "udev_enumerate_new fails";
     return false;
   }
 
   err = device::udev_enumerate_add_match_subsystem(enumerate.get(),
                                                    kUdevSubsystemSound);
   if (err) {
     VLOG(1) << "udev_enumerate_add_match_subsystem fails: "
-            << safe_strerror(-err);
+            << base::safe_strerror(-err);
     return false;
   }
 
   err = device::udev_enumerate_scan_devices(enumerate.get());
   if (err) {
-    VLOG(1) << "udev_enumerate_scan_devices fails: " << safe_strerror(-err);
+    VLOG(1) << "udev_enumerate_scan_devices fails: "
+            << base::safe_strerror(-err);
     return false;
   }
 
   udev_list_entry* list_entry;
   auto* devices = device::udev_enumerate_get_list_entry(enumerate.get());
   udev_list_entry_foreach(list_entry, devices) {
     const char* path = device::udev_list_entry_get_name(list_entry);
     device::ScopedUdevDevicePtr dev(
         device::udev_device_new_from_syspath(udev_.get(), path));
     if (dev.get())
@@ skipping 70 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media