Move device/core files to device/base directory.

device/base/device_monitor_win.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 "device/core/device_monitor_win.h"
+#include "device/base/device_monitor_win.h"
 
 #include <dbt.h>
 #include <windows.h>
 
 #include <map>
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 22 matching lines @@
 // This singleton class manages a shared message window for all registered
 // device notification observers. It vends one instance of DeviceManagerWin for
 // each unique GUID it sees.
 class DeviceMonitorMessageWindow {
  public:
   static DeviceMonitorMessageWindow* GetInstance() {
     if (!g_message_window) {
       g_message_window = new DeviceMonitorMessageWindow();
       if (g_message_window->Init()) {
         base::AtExitManager::RegisterTask(
-          base::Bind(&base::DeletePointer<DeviceMonitorMessageWindow>,
-                     base::Unretained(g_message_window)));
+            base::Bind(&base::DeletePointer<DeviceMonitorMessageWindow>,
+                       base::Unretained(g_message_window)));
       } else {
         delete g_message_window;
         g_message_window = nullptr;
       }
     }
     return g_message_window;
   }
 
   DeviceMonitorWin* GetForDeviceInterface(const GUID& device_interface) {
     std::unique_ptr<DeviceMonitorWin>& device_monitor =
         device_monitors_[device_interface];
     if (!device_monitor) {
       device_monitor.reset(new DeviceMonitorWin());
     }
     return device_monitor.get();
   }
 
   DeviceMonitorWin* GetForAllInterfaces() { return &all_device_monitor_; }
 
  private:
   friend void base::DeletePointer<DeviceMonitorMessageWindow>(
       DeviceMonitorMessageWindow* message_window);
 
-  DeviceMonitorMessageWindow() {
-  }
+  DeviceMonitorMessageWindow() {}
 
   ~DeviceMonitorMessageWindow() {
     if (notify_handle_) {
       UnregisterDeviceNotification(notify_handle_);
     }
   }
 
   bool Init() {
     window_.reset(new base::win::MessageWindow());
     if (!window_->CreateNamed(
@@ skipping 65 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DeviceMonitorMessageWindow);
 };
 
 void DeviceMonitorWin::Observer::OnDeviceAdded(const GUID& class_guid,
                                                const std::string& device_path) {
 }
 
 void DeviceMonitorWin::Observer::OnDeviceRemoved(
     const GUID& class_guid,
-    const std::string& device_path) {
-}
+    const std::string& device_path) {}
 
 // static
 DeviceMonitorWin* DeviceMonitorWin::GetForDeviceInterface(
     const GUID& device_interface) {
   DeviceMonitorMessageWindow* message_window =
       DeviceMonitorMessageWindow::GetInstance();
   if (message_window) {
     return message_window->GetForDeviceInterface(device_interface);
   }
   return nullptr;
 }
 
 // static
 DeviceMonitorWin* DeviceMonitorWin::GetForAllInterfaces() {
   DeviceMonitorMessageWindow* message_window =
       DeviceMonitorMessageWindow::GetInstance();
   if (message_window) {
     return message_window->GetForAllInterfaces();
   }
   return nullptr;
 }
 
-DeviceMonitorWin::~DeviceMonitorWin() {
-}
+DeviceMonitorWin::~DeviceMonitorWin() {}
 
 void DeviceMonitorWin::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void DeviceMonitorWin::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-DeviceMonitorWin::DeviceMonitorWin() {
-}
+DeviceMonitorWin::DeviceMonitorWin() {}
 
 void DeviceMonitorWin::NotifyDeviceAdded(const GUID& class_guid,
                                          const std::string& device_path) {
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnDeviceAdded(class_guid, device_path));
+  for (auto& observer : observer_list_)
+    observer.OnDeviceAdded(class_guid, device_path);
 }
 
 void DeviceMonitorWin::NotifyDeviceRemoved(const GUID& class_guid,
                                            const std::string& device_path) {
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnDeviceRemoved(class_guid, device_path));
+  for (auto& observer : observer_list_)
+    observer.OnDeviceRemoved(class_guid, device_path);
 }
 
 }  // namespace device