Add queryForNewLocalDevices to gcdPrivate

chrome/browser/extensions/api/gcd_private/gcd_private_api.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 "chrome/browser/extensions/api/gcd_private/gcd_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/local_discovery/cloud_device_list.h"
 #include "chrome/browser/local_discovery/cloud_print_printer_list.h"
 #include "chrome/browser/local_discovery/gcd_constants.h"
 #include "chrome/browser/local_discovery/privet_device_lister_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 
 namespace extensions {
 
 namespace gcd_private = api::gcd_private;
 
 namespace {
 
-scoped_ptr<Event> MakeCloudDeviceStateChangedEvent(
+scoped_ptr<Event> MakeLocalDeviceStateChangedEvent(
     bool available,
     const gcd_private::GCDDevice& device) {
   scoped_ptr<base::ListValue> params =
-      gcd_private::OnCloudDeviceStateChanged::Create(available, device);
+      gcd_private::OnLocalDeviceStateChanged::Create(available, device);
   scoped_ptr<Event> event(new Event(
-      gcd_private::OnCloudDeviceStateChanged::kEventName, params.Pass()));
+      gcd_private::OnLocalDeviceStateChanged::kEventName, params.Pass()));
   return event.Pass();
 }
 
 const int kNumRequestsNeeded = 2;
 
 const char kIDPrefixCloudPrinter[] = "cloudprint:";
 const char kIDPrefixGcd[] = "gcd:";
 const char kIDPrefixMdns[] = "mdns:";
 
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
@@ skipping 23 matching lines @@
       token_service,
       signin_manager->GetAuthenticatedAccountId());
 }
 
 }  // namespace
 
 GcdPrivateAPI::GcdPrivateAPI(content::BrowserContext* context)
     : num_device_listeners_(0), browser_context_(context) {
   DCHECK(browser_context_);
   EventRouter::Get(context)->RegisterObserver(
-      this, gcd_private::OnCloudDeviceStateChanged::kEventName);
+      this, gcd_private::OnLocalDeviceStateChanged::kEventName);
 }
 
 GcdPrivateAPI::~GcdPrivateAPI() {
 }
 
 // static
 BrowserContextKeyedAPIFactory<GcdPrivateAPI>*
 GcdPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
@@ skipping 26 matching lines @@
                        base::Unretained(this))));
     bootstrapping_device_lister_->Start();
 #endif  // ENABLE_WIFI_BOOTSTRAPPING
   }
 
   for (GCDDeviceMap::iterator i = known_devices_.begin();
        i != known_devices_.end();
        i++) {
     EventRouter::Get(browser_context_)->DispatchEventToExtension(
         details.extension_id,
-        MakeCloudDeviceStateChangedEvent(true, *i->second));
+        MakeLocalDeviceStateChangedEvent(true, *i->second));
   }
 }
 
 void GcdPrivateAPI::OnListenerRemoved(const EventListenerInfo& details) {
   num_device_listeners_--;
 
   if (num_device_listeners_ == 0) {
     privet_device_lister_.reset();
     service_discovery_client_ = NULL;
 
@@ skipping 13 matching lines @@
   device->id_string = kIDPrefixMdns + name;
   device->device_type = description.type;
   device->device_name = description.name;
   device->device_description = description.description;
   if (!description.id.empty())
     device->cloud_id.reset(new std::string(description.id));
 
   known_devices_[device->id_string] = device;
 
   EventRouter::Get(browser_context_)
-      ->BroadcastEvent(MakeCloudDeviceStateChangedEvent(true, *device));
+      ->BroadcastEvent(MakeLocalDeviceStateChangedEvent(true, *device));
 }
 
 void GcdPrivateAPI::DeviceRemoved(const std::string& name) {
   GCDDeviceMap::iterator found = known_devices_.find(kIDPrefixMdns + name);
   DCHECK(found != known_devices_.end());
   linked_ptr<gcd_private::GCDDevice> device = found->second;
   known_devices_.erase(found);
 
   EventRouter::Get(browser_context_)
-      ->BroadcastEvent(MakeCloudDeviceStateChangedEvent(false, *device));
+      ->BroadcastEvent(MakeLocalDeviceStateChangedEvent(false, *device));
 }
 
 void GcdPrivateAPI::DeviceCacheFlushed() {
   for (GCDDeviceMap::iterator i = known_devices_.begin();
        i != known_devices_.end();
        i++) {
     EventRouter::Get(browser_context_)
-        ->BroadcastEvent(MakeCloudDeviceStateChangedEvent(false, *i->second));
+        ->BroadcastEvent(MakeLocalDeviceStateChangedEvent(false, *i->second));
   }
 
   known_devices_.clear();
 }
 
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
 void GcdPrivateAPI::OnBootstrappingDeviceUpdate(
     bool available,
     const local_discovery::wifi::BootstrappingDeviceDescription& description) {
   linked_ptr<gcd_private::GCDDevice> device;
   if (available) {
     device.reset(new gcd_private::GCDDevice);
     device->setup_type = gcd_private::SETUP_TYPE_WIFI;
     device->id_string = kIDPrefixWifi + description.device_ssid;
     device->device_type = description.device_kind;
     device->device_name = description.device_name;
 
     known_devices_[device->id_string] = device;
   } else {
     GCDDeviceMap::iterator found =
         known_devices_.find(kIDPrefixWifi + description.device_ssid);
     DCHECK(found != known_devices_.end());
     device = found->second;
     known_devices_.erase(found);
   }
 
   EventRouter::Get(browser_context_)
-      ->BroadcastEvent(MakeCloudDeviceStateChangedEvent(available, *device));
+      ->BroadcastEvent(MakeLocalDeviceStateChangedEvent(available, *device));
 }
 #endif  // ENABLE_WIFI_BOOTSTRAPPING
 
+bool GcdPrivateAPI::QueryForDevices() {
+  if (!privet_device_lister_)
+    return false;
+
+  privet_device_lister_->DiscoverNewDevices(true);
+
+  return true;
+}
+
 // static
 void GcdPrivateAPI::SetGCDApiFlowFactoryForTests(
     GCDApiFlowFactoryForTests* factory) {
   g_gcd_api_flow_factory = factory;
 }
 
 GcdPrivateGetCloudDeviceListFunction::GcdPrivateGetCloudDeviceListFunction() {
 }
 GcdPrivateGetCloudDeviceListFunction::~GcdPrivateGetCloudDeviceListFunction() {
 }
@@ skipping 61 matching lines @@
 
     devices.push_back(device);
   }
 
   results_ = gcd_private::GetCloudDeviceList::Results::Create(devices);
 
   SendResponse(true);
   Release();
 }
 
+GcdPrivateQueryForNewLocalDevicesFunction::
+    GcdPrivateQueryForNewLocalDevicesFunction() {
+}
+
+GcdPrivateQueryForNewLocalDevicesFunction::
+    ~GcdPrivateQueryForNewLocalDevicesFunction() {
+}
+
+bool GcdPrivateQueryForNewLocalDevicesFunction::RunSync() {
+  GcdPrivateAPI* gcd_api =
+      BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
+
+  if (!gcd_api)
+    return false;
+
+  if (!gcd_api->QueryForDevices()) {
+    error_ =
+        "You must first subscribe to onLocalDeviceStateChanged notifications";
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace extensions