[Device Discovery] Move files from browser/extensions/api/dial to browser/media/router/discovery/di…

chrome/browser/extensions/api/dial/dial_api.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/dial/dial_api.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
-#include "chrome/browser/extensions/api/dial/device_description_fetcher.h"
 #include "chrome/browser/extensions/api/dial/dial_api_factory.h"
+#include "chrome/browser/media/router/discovery/dial/device_description_fetcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/dial.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system.h"
 #include "url/gurl.h"
 
 using base::TimeDelta;
 using content::BrowserThread;
-using extensions::api::dial::DeviceDescriptionFetcher;
-using extensions::api::dial::DialDeviceData;
-using extensions::api::dial::DialDeviceDescriptionData;
-using extensions::api::dial::DialRegistry;
+using media_router::DeviceDescriptionFetcher;
+using media_router::DialDeviceData;
+using media_router::DialDeviceDescriptionData;
+using media_router::DialRegistry;
 
 namespace extensions {
 
 namespace {
 
 // How often to poll for devices.
 const int kDialRefreshIntervalSecs = 120;
 
 // We prune a device if it does not respond after this time.
 const int kDialExpirationSecs = 240;
@@ skipping 46 matching lines @@
   VLOG(2) << "DIAL device event listener added.";
   dial_registry()->OnListenerAdded();
 }
 
 void DialAPI::NotifyListenerRemovedOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(2) << "DIAL device event listener removed";
   dial_registry()->OnListenerRemoved();
 }
 
+void DialAPI::FillDialDevice(const media_router::DialDeviceData& device_data,
+                             api::dial::DialDevice* device) const {
+  DCHECK(!device_data.device_id().empty());
+  DCHECK(media_router::DialDeviceData::IsDeviceDescriptionUrl(
+      device_data.device_description_url()));
+  device->device_label = device_data.label();
+  device->device_description_url = device_data.device_description_url().spec();
+  if (device_data.has_config_id())
+    device->config_id.reset(new int(device_data.config_id()));
+}
+
 void DialAPI::OnDialDeviceEvent(const DialRegistry::DeviceList& devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&DialAPI::SendEventOnUIThread, this, devices));
 }
 
 void DialAPI::OnDialError(const DialRegistry::DialErrorCode code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&DialAPI::SendErrorOnUIThread, this, code));
 }
 
 void DialAPI::SendEventOnUIThread(const DialRegistry::DeviceList& devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::vector<api::dial::DialDevice> args;
   for (const DialDeviceData& device : devices) {
     api::dial::DialDevice api_device;
-    device.FillDialDevice(&api_device);
+    FillDialDevice(device, &api_device);
     args.push_back(std::move(api_device));
   }
   std::unique_ptr<base::ListValue> results =
       api::dial::OnDeviceList::Create(args);
   std::unique_ptr<Event> event(new Event(events::DIAL_ON_DEVICE_LIST,
                                          api::dial::OnDeviceList::kEventName,
                                          std::move(results)));
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
 }
 
@@ skipping 26 matching lines @@
       api::dial::OnError::Create(dial_error);
   std::unique_ptr<Event> event(new Event(events::DIAL_ON_ERROR,
                                          api::dial::OnError::kEventName,
                                          std::move(results)));
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
 }
 
 void DialAPI::ShutdownOnUIThread() {}
 
 void DialAPI::SetDeviceForTest(
-    const api::dial::DialDeviceData& device_data,
-    const api::dial::DialDeviceDescriptionData& device_description) {
+    const media_router::DialDeviceData& device_data,
+    const media_router::DialDeviceDescriptionData& device_description) {
   test_device_data_ = base::MakeUnique<DialDeviceData>(device_data);
   test_device_description_ =
       base::MakeUnique<DialDeviceDescriptionData>(device_description);
 }
 
 DialDiscoverNowFunction::DialDiscoverNowFunction()
     : dial_(NULL), result_(false) {
 }
 
 bool DialDiscoverNowFunction::Prepare() {
@@ skipping 61 matching lines @@
   device_description_fetcher_ = base::MakeUnique<DeviceDescriptionFetcher>(
       url, Profile::FromBrowserContext(browser_context())->GetRequestContext(),
       base::BindOnce(&DialFetchDeviceDescriptionFunction::OnFetchComplete,
                      this),
       base::BindOnce(&DialFetchDeviceDescriptionFunction::OnFetchError, this));
 
   device_description_fetcher_->Start();
 }
 
 void DialFetchDeviceDescriptionFunction::OnFetchComplete(
-    const api::dial::DialDeviceDescriptionData& result) {
+    const media_router::DialDeviceDescriptionData& result) {
   // Destroy the DeviceDescriptionFetcher since it still contains a reference
   // to |this| in its un-invoked callback.
   device_description_fetcher_.reset();
   api::dial::DialDeviceDescription device_description;
   device_description.device_label = params_->device_label;
   device_description.app_url = result.app_url.spec();
   device_description.device_description = result.device_description;
   SetResult(device_description.ToValue());
   SendResponse(true);
 }
 
 void DialFetchDeviceDescriptionFunction::OnFetchError(
     const std::string& message) {
   // Destroy the DeviceDescriptionFetcher since it still contains a reference
   // to |this| in its un-invoked callback.
   device_description_fetcher_.reset();
   SetError(message);
   SendResponse(false);
 }
 
 }  // namespace extensions