Move classes in the device.usb Mojo namespace to device.mojom

device/usb/mojo/device_manager_impl.cc

 // Copyright 2015 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/usb/mojo/device_manager_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 10 matching lines @@
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_device_filter.h"
 #include "device/usb/usb_service.h"
 
 namespace device {
 namespace usb {
 
 // static
 void DeviceManagerImpl::Create(
     base::WeakPtr<PermissionProvider> permission_provider,
-    DeviceManagerRequest request) {
+    mojom::UsbDeviceManagerRequest request) {
   DCHECK(DeviceClient::Get());
   UsbService* service = DeviceClient::Get()->GetUsbService();
   if (!service)
     return;
 
   auto* device_manager_impl =
       new DeviceManagerImpl(std::move(permission_provider), service);
   device_manager_impl->binding_ = mojo::MakeStrongBinding(
       base::WrapUnique(device_manager_impl), std::move(request));
 }
 
 DeviceManagerImpl::DeviceManagerImpl(
     base::WeakPtr<PermissionProvider> permission_provider,
     UsbService* usb_service)
     : permission_provider_(permission_provider),
       usb_service_(usb_service),
       observer_(this),
       weak_factory_(this) {
   // This object owns itself and will be destroyed if the message pipe it is
   // bound to is closed, the message loop is destructed, or the UsbService is
   // shut down.
   observer_.Add(usb_service_);
 }
 
 DeviceManagerImpl::~DeviceManagerImpl() {
 }
 
-void DeviceManagerImpl::GetDevices(EnumerationOptionsPtr options,
+void DeviceManagerImpl::GetDevices(mojom::UsbEnumerationOptionsPtr options,
                                    const GetDevicesCallback& callback) {
   usb_service_->GetDevices(base::Bind(&DeviceManagerImpl::OnGetDevices,
                                       weak_factory_.GetWeakPtr(),
                                       base::Passed(&options), callback));
 }
 
 void DeviceManagerImpl::GetDevice(const std::string& guid,
-                                  DeviceRequest device_request) {
+                                  mojom::UsbDeviceRequest device_request) {
   scoped_refptr<UsbDevice> device = usb_service_->GetDevice(guid);
   if (!device)
     return;
 
   if (permission_provider_ &&
       permission_provider_->HasDevicePermission(device)) {
     DeviceImpl::Create(std::move(device), permission_provider_,
                        std::move(device_request));
   }
 }
 
-void DeviceManagerImpl::SetClient(DeviceManagerClientPtr client) {
+void DeviceManagerImpl::SetClient(mojom::UsbDeviceManagerClientPtr client) {
   client_ = std::move(client);
 }
 
 void DeviceManagerImpl::OnGetDevices(
-    EnumerationOptionsPtr options,
+    mojom::UsbEnumerationOptionsPtr options,
     const GetDevicesCallback& callback,
     const std::vector<scoped_refptr<UsbDevice>>& devices) {
   std::vector<UsbDeviceFilter> filters;
   if (options && options->filters)
     filters.swap(*options->filters);
 
-  std::vector<DeviceInfoPtr> device_infos;
+  std::vector<mojom::UsbDeviceInfoPtr> device_infos;
   for (const auto& device : devices) {
     if (UsbDeviceFilter::MatchesAny(*device, filters)) {
       if (permission_provider_ &&
           permission_provider_->HasDevicePermission(device)) {
-        device_infos.push_back(DeviceInfo::From(*device));
+        device_infos.push_back(mojom::UsbDeviceInfo::From(*device));
       }
     }
   }
 
   callback.Run(std::move(device_infos));
 }
 
 void DeviceManagerImpl::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
   if (client_ && permission_provider_ &&
       permission_provider_->HasDevicePermission(device))
-    client_->OnDeviceAdded(DeviceInfo::From(*device));
+    client_->OnDeviceAdded(mojom::UsbDeviceInfo::From(*device));
 }
 
 void DeviceManagerImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
   if (client_ && permission_provider_ &&
       permission_provider_->HasDevicePermission(device))
-    client_->OnDeviceRemoved(DeviceInfo::From(*device));
+    client_->OnDeviceRemoved(mojom::UsbDeviceInfo::From(*device));
 }
 
 void DeviceManagerImpl::WillDestroyUsbService() {
   binding_->Close();
 }
 
 }  // namespace usb
 }  // namespace device