#include "chrome/browser/extensions/api/gcd_private/gcd_private_api.h"
#include "base/lazy_instance.h"
+#include "base/memory/linked_ptr.h"
#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "base/strings/stringprintf.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_api_flow.h"
#include "chrome/browser/local_discovery/gcd_constants.h"
+#include "chrome/browser/local_discovery/privet_device_lister_impl.h"
+#include "chrome/browser/local_discovery/privet_http_impl.h"
+#include "chrome/browser/local_discovery/privetv3_session.h"
+#include "chrome/browser/local_discovery/service_discovery_shared_client.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"
+#include "extensions/browser/event_router.h"
+#include "net/base/net_util.h"
+
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+#include "chrome/browser/local_discovery/wifi/wifi_manager.h"
+#endif
namespace extensions {
-using extensions::api::gcd_private::GCDDevice;
+namespace gcd_private = api::gcd_private;
namespace {
const char kIDPrefixCloudPrinter[] = "cloudprint:";
const char kIDPrefixGcd[] = "gcd:";
+const char kIDPrefixMdns[] = "mdns:";
+
+const char kPrivatAPISetup[] = "/privet/v3/setup/start";
+const char kPrivetKeyWifi[] = "wifi";
+const char kPrivetKeyPassphrase[] = "passphrase";
+const char kPrivetKeySSID[] = "ssid";
+const char kPrivetKeyPassphraseDotted[] = "wifi.passphrase";
+
+scoped_ptr<Event> MakeDeviceStateChangedEvent(
+ const gcd_private::GCDDevice& device) {
+ scoped_ptr<base::ListValue> params =
+ gcd_private::OnDeviceStateChanged::Create(device);
+ scoped_ptr<Event> event(
+ new Event(gcd_private::OnDeviceStateChanged::kEventName, params.Pass()));
+ return event.Pass();
+}
+
+scoped_ptr<Event> MakeDeviceRemovedEvent(const std::string& device) {
+ scoped_ptr<base::ListValue> params =
+ gcd_private::OnDeviceRemoved::Create(device);
+ scoped_ptr<Event> event(
+ new Event(gcd_private::OnDeviceRemoved::kEventName, params.Pass()));
+ return event.Pass();
+}
GcdPrivateAPI::GCDApiFlowFactoryForTests* g_gcd_api_flow_factory = NULL;
} // namespace
+class GcdPrivateSessionHolder;
+
+class GcdPrivateAPIImpl : public EventRouter::Observer,
+ public local_discovery::PrivetDeviceLister::Delegate {
+ public:
+ typedef base::Callback<void(bool success)> SuccessCallback;
+
+ typedef base::Callback<void(int session_id,
+ api::gcd_private::Status status,
+ const std::vector<api::gcd_private::PairingType>&
+ pairing_types)> EstablishSessionCallback;
+
+ typedef base::Callback<void(api::gcd_private::Status status)> SessionCallback;
+
+ typedef base::Callback<void(api::gcd_private::Status status,
+ const base::DictionaryValue& response)>
+ MessageResponseCallback;
+
+ explicit GcdPrivateAPIImpl(content::BrowserContext* context);
+ virtual ~GcdPrivateAPIImpl();
+
+ static GcdPrivateAPIImpl* Get(content::BrowserContext* context);
+
+ bool QueryForDevices();
+
+ void EstablishSession(const std::string& ip_address,
+ int port,
+ const EstablishSessionCallback& callback);
+
+ void StartPairing(int session_id,
+ api::gcd_private::PairingType pairing_type,
+ const SessionCallback& callback);
+
+ void ConfirmCode(int session_id,
+ const std::string& code,
+ const SessionCallback& callback);
+
+ void SendMessage(int session_id,
+ const std::string& api,
+ const base::DictionaryValue& input,
+ const MessageResponseCallback& callback);
+
+ void RequestWifiPassword(const std::string& ssid,
+ const SuccessCallback& callback);
+
+ void RemoveSession(int session_id);
+
+ scoped_ptr<base::ListValue> GetPrefetchedSSIDList();
+
+ private:
+ typedef std::map<std::string /* id_string */,
+ linked_ptr<api::gcd_private::GCDDevice> > GCDDeviceMap;
+
+ typedef std::map<std::string /* ssid */, std::string /* password */>
+ PasswordMap;
+
+ // EventRouter::Observer implementation.
+ void OnListenerAdded(const EventListenerInfo& details) override;
+ void OnListenerRemoved(const EventListenerInfo& details) override;
+
+ // local_discovery::PrivetDeviceLister implementation.
+ void DeviceChanged(
+ bool added,
+ const std::string& name,
+ const local_discovery::DeviceDescription& description) override;
+ void DeviceRemoved(const std::string& name) override;
+ void DeviceCacheFlushed() override;
+
+ void SendMessageInternal(int session_id,
+ const std::string& api,
+ const base::DictionaryValue& input,
+ const MessageResponseCallback& callback);
+
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+ void OnWifiPassword(const SuccessCallback& callback,
+ bool success,
+ const std::string& ssid,
+ const std::string& password);
+ void StartWifiIfNotStarted();
+#endif
+
+ int num_device_listeners_;
+ scoped_refptr<local_discovery::ServiceDiscoverySharedClient>
+ service_discovery_client_;
+ scoped_ptr<local_discovery::PrivetDeviceLister> privet_device_lister_;
+ GCDDeviceMap known_devices_;
+
+ std::map<int, linked_ptr<local_discovery::PrivetV3Session>> sessions_;
+ int last_session_id_;
+
+ content::BrowserContext* const browser_context_;
+
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+ scoped_ptr<local_discovery::wifi::WifiManager> wifi_manager_;
+#endif
+ PasswordMap wifi_passwords_;
+};
+
+
+GcdPrivateAPIImpl::GcdPrivateAPIImpl(content::BrowserContext* context)
+ : num_device_listeners_(0), last_session_id_(0), browser_context_(context) {
+ DCHECK(browser_context_);
+ if (EventRouter::Get(context)) {
+ EventRouter::Get(context)
+ ->RegisterObserver(this, gcd_private::OnDeviceStateChanged::kEventName);
+ EventRouter::Get(context)
+ ->RegisterObserver(this, gcd_private::OnDeviceRemoved::kEventName);
+ }
+}
+
+GcdPrivateAPIImpl::~GcdPrivateAPIImpl() {
+ if (EventRouter::Get(browser_context_)) {
+ EventRouter::Get(browser_context_)->UnregisterObserver(this);
+ }
+}
+
+void GcdPrivateAPIImpl::OnListenerAdded(const EventListenerInfo& details) {
+ if (details.event_name == gcd_private::OnDeviceStateChanged::kEventName ||
+ details.event_name == gcd_private::OnDeviceRemoved::kEventName) {
+ num_device_listeners_++;
+
+ if (num_device_listeners_ == 1) {
+ service_discovery_client_ =
+ local_discovery::ServiceDiscoverySharedClient::GetInstance();
+ privet_device_lister_.reset(new local_discovery::PrivetDeviceListerImpl(
+ service_discovery_client_.get(), this));
+ privet_device_lister_->Start();
+ }
+
+ for (GCDDeviceMap::iterator i = known_devices_.begin();
+ i != known_devices_.end();
+ i++) {
+ EventRouter::Get(browser_context_)->DispatchEventToExtension(
+ details.extension_id, MakeDeviceStateChangedEvent(*i->second));
+ }
+ }
+}
+
+void GcdPrivateAPIImpl::OnListenerRemoved(const EventListenerInfo& details) {
+ if (details.event_name == gcd_private::OnDeviceStateChanged::kEventName ||
+ details.event_name == gcd_private::OnDeviceRemoved::kEventName) {
+ num_device_listeners_--;
+
+ if (num_device_listeners_ == 0) {
+ privet_device_lister_.reset();
+ service_discovery_client_ = NULL;
+ }
+ }
+}
+
+void GcdPrivateAPIImpl::DeviceChanged(
+ bool added,
+ const std::string& name,
+ const local_discovery::DeviceDescription& description) {
+ linked_ptr<gcd_private::GCDDevice> device(new gcd_private::GCDDevice);
+ device->setup_type = gcd_private::SETUP_TYPE_MDNS;
+ device->device_id = 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->device_id] = device;
+
+ EventRouter::Get(browser_context_)
+ ->BroadcastEvent(MakeDeviceStateChangedEvent(*device));
+}
+
+void GcdPrivateAPIImpl::DeviceRemoved(const std::string& name) {
+ GCDDeviceMap::iterator found = known_devices_.find(kIDPrefixMdns + name);
+ linked_ptr<gcd_private::GCDDevice> device = found->second;
+ known_devices_.erase(found);
+
+ EventRouter::Get(browser_context_)
+ ->BroadcastEvent(MakeDeviceRemovedEvent(device->device_id));
+}
+
+void GcdPrivateAPIImpl::DeviceCacheFlushed() {
+ for (GCDDeviceMap::iterator i = known_devices_.begin();
+ i != known_devices_.end();
+ i++) {
+ EventRouter::Get(browser_context_)
+ ->BroadcastEvent(MakeDeviceRemovedEvent(i->second->device_id));
+ }
+
+ known_devices_.clear();
+}
+
+// static
+GcdPrivateAPIImpl* GcdPrivateAPIImpl::Get(content::BrowserContext* context) {
+ GcdPrivateAPI* gcd_api =
+ BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(context);
+ return gcd_api ? gcd_api->impl_.get() : NULL;
+}
+
+bool GcdPrivateAPIImpl::QueryForDevices() {
+ if (!privet_device_lister_)
+ return false;
+
+ privet_device_lister_->DiscoverNewDevices(true);
+
+ return true;
+}
+
+void GcdPrivateAPIImpl::EstablishSession(
+ const std::string& ip_address,
+ int port,
+ const EstablishSessionCallback& callback) {
+ std::string host_string;
+ net::IPAddressNumber address_number;
+
+ if (net::ParseIPLiteralToNumber(ip_address, &address_number) &&
+ address_number.size() == net::kIPv6AddressSize) {
+ host_string = base::StringPrintf("[%s]", ip_address.c_str());
+ } else {
+ host_string = ip_address;
+ }
+
+ scoped_ptr<local_discovery::PrivetHTTPClient> http_client(
+ new local_discovery::PrivetHTTPClientImpl(
+ "", net::HostPortPair(host_string, port),
+ browser_context_->GetRequestContext()));
+
+ int session_id = last_session_id_++;
+ linked_ptr<local_discovery::PrivetV3Session> session_handler(
+ new local_discovery::PrivetV3Session(http_client.Pass()));
+ sessions_[session_id] = session_handler;
+ session_handler->Init(base::Bind(callback, session_id));
+}
+
+void GcdPrivateAPIImpl::StartPairing(int session_id,
+ api::gcd_private::PairingType pairing_type,
+ const SessionCallback& callback) {
+ auto found = sessions_.find(session_id);
+
+ if (found == sessions_.end())
+ return callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR);
+
+ found->second->StartPairing(pairing_type, callback);
+}
+
+void GcdPrivateAPIImpl::ConfirmCode(int session_id,
+ const std::string& code,
+ const SessionCallback& callback) {
+ auto found = sessions_.find(session_id);
+
+ if (found == sessions_.end())
+ return callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR);
+
+ found->second->ConfirmCode(code, callback);
+}
+
+void GcdPrivateAPIImpl::SendMessage(int session_id,
+ const std::string& api,
+ const base::DictionaryValue& input,
+ const MessageResponseCallback& callback) {
+ const base::DictionaryValue* input_actual = &input;
+ scoped_ptr<base::DictionaryValue> input_cloned;
+
+ if (api == kPrivatAPISetup) {
+ const base::DictionaryValue* wifi = NULL;
+
+ if (input.GetDictionary(kPrivetKeyWifi, &wifi)) {
+ std::string ssid;
+
+ if (!wifi->GetString(kPrivetKeySSID, &ssid)) {
+ callback.Run(gcd_private::STATUS_SETUPPARSEERROR,
+ base::DictionaryValue());
+ return;
+ }
+
+ if (!wifi->HasKey(kPrivetKeyPassphrase)) {
+ // If the message is a setup message, has a wifi section, try sending
+ // the passphrase.
+
+ PasswordMap::iterator found = wifi_passwords_.find(ssid);
+ if (found == wifi_passwords_.end()) {
+ callback.Run(gcd_private::STATUS_WIFIPASSWORDERROR,
+ base::DictionaryValue());
+ return;
+ }
+
+ input_cloned.reset(input.DeepCopy());
+ input_cloned->SetString(kPrivetKeyPassphraseDotted, found->second);
+ input_actual = input_cloned.get();
+ }
+ }
+ }
+
+ auto found = sessions_.find(session_id);
+
+ if (found == sessions_.end()) {
+ callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR,
+ base::DictionaryValue());
+ return;
+ }
+
+ found->second->SendMessage(api, *input_actual, callback);
+}
+
+void GcdPrivateAPIImpl::RequestWifiPassword(const std::string& ssid,
+ const SuccessCallback& callback) {
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+ StartWifiIfNotStarted();
+ wifi_manager_->RequestNetworkCredentials(
+ ssid,
+ base::Bind(&GcdPrivateAPIImpl::OnWifiPassword,
+ base::Unretained(this),
+ callback));
+#else
+ callback.Run(false);
+#endif
+}
+
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+void GcdPrivateAPIImpl::OnWifiPassword(const SuccessCallback& callback,
+ bool success,
+ const std::string& ssid,
+ const std::string& password) {
+ if (success) {
+ wifi_passwords_[ssid] = password;
+ }
+
+ callback.Run(success);
+}
+
+void GcdPrivateAPIImpl::StartWifiIfNotStarted() {
+ if (!wifi_manager_) {
+ wifi_manager_ = local_discovery::wifi::WifiManager::Create();
+ wifi_manager_->Start();
+ }
+}
+
+#endif
+
+void GcdPrivateAPIImpl::RemoveSession(int session_id) {
+ sessions_.erase(session_id);
+}
+
+scoped_ptr<base::ListValue> GcdPrivateAPIImpl::GetPrefetchedSSIDList() {
+ scoped_ptr<base::ListValue> retval(new base::ListValue);
+
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+ for (PasswordMap::iterator i = wifi_passwords_.begin();
+ i != wifi_passwords_.end();
+ i++) {
+ retval->AppendString(i->first);
+ }
+#endif
+
+ return retval.Pass();
+}
+
+
+
GcdPrivateAPI::GcdPrivateAPI(content::BrowserContext* context)
- : browser_context_(context) {
+ : impl_(new GcdPrivateAPIImpl(context)) {
}
GcdPrivateAPI::~GcdPrivateAPI() {
GcdPrivateGetCloudDeviceListFunction::GcdPrivateGetCloudDeviceListFunction() {
}
+
GcdPrivateGetCloudDeviceListFunction::~GcdPrivateGetCloudDeviceListFunction() {
}
return;
}
- std::vector<linked_ptr<GCDDevice> > devices;
+ std::vector<linked_ptr<gcd_private::GCDDevice> > devices;
for (DeviceList::iterator i = devices_.begin(); i != devices_.end(); i++) {
- linked_ptr<GCDDevice> device(new GCDDevice);
- device->setup_type = extensions::api::gcd_private::SETUP_TYPE_CLOUD;
+ linked_ptr<gcd_private::GCDDevice> device(new gcd_private::GCDDevice);
+ device->setup_type = gcd_private::SETUP_TYPE_CLOUD;
if (i->type == local_discovery::kGCDTypePrinter) {
- device->id_string = kIDPrefixCloudPrinter + i->id;
+ device->device_id = kIDPrefixCloudPrinter + i->id;
} else {
- device->id_string = kIDPrefixGcd + i->id;
+ device->device_id = kIDPrefixGcd + i->id;
}
device->cloud_id.reset(new std::string(i->id));
devices.push_back(device);
}
- results_ = extensions::api::gcd_private::GetCloudDeviceList::Results::Create(
- devices);
+ results_ = gcd_private::GetCloudDeviceList::Results::Create(devices);
SendResponse(true);
Release();
}
+GcdPrivateQueryForNewLocalDevicesFunction::
+ GcdPrivateQueryForNewLocalDevicesFunction() {
+}
+
+GcdPrivateQueryForNewLocalDevicesFunction::
+ ~GcdPrivateQueryForNewLocalDevicesFunction() {
+}
+
+bool GcdPrivateQueryForNewLocalDevicesFunction::RunSync() {
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ if (!gcd_api->QueryForDevices()) {
+ error_ =
+ "You must first subscribe to onDeviceStateChanged or onDeviceRemoved "
+ "notifications";
+ return false;
+ }
+
+ return true;
+}
+
+GcdPrivatePrefetchWifiPasswordFunction::
+ GcdPrivatePrefetchWifiPasswordFunction() {
+}
+
+GcdPrivatePrefetchWifiPasswordFunction::
+ ~GcdPrivatePrefetchWifiPasswordFunction() {
+}
+
+bool GcdPrivatePrefetchWifiPasswordFunction::RunAsync() {
+ scoped_ptr<gcd_private::PrefetchWifiPassword::Params> params =
+ gcd_private::PrefetchWifiPassword::Params::Create(*args_);
+
+ if (!params)
+ return false;
+
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ gcd_api->RequestWifiPassword(
+ params->ssid,
+ base::Bind(&GcdPrivatePrefetchWifiPasswordFunction::OnResponse, this));
+
+ return true;
+}
+
+void GcdPrivatePrefetchWifiPasswordFunction::OnResponse(bool response) {
+ scoped_ptr<base::FundamentalValue> response_value(
+ new base::FundamentalValue(response));
+ SetResult(response_value.release());
+ SendResponse(true);
+}
+
+GcdPrivateEstablishSessionFunction::GcdPrivateEstablishSessionFunction() {
+}
+
+GcdPrivateEstablishSessionFunction::~GcdPrivateEstablishSessionFunction() {
+}
+
+bool GcdPrivateEstablishSessionFunction::RunAsync() {
+ scoped_ptr<gcd_private::EstablishSession::Params> params =
+ gcd_private::EstablishSession::Params::Create(*args_);
+
+ if (!params)
+ return false;
+
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ GcdPrivateAPIImpl::EstablishSessionCallback callback = base::Bind(
+ &GcdPrivateEstablishSessionFunction::OnSessionInitialized, this);
+ gcd_api->EstablishSession(params->ip_address, params->port, callback);
+
+ return true;
+}
+
+void GcdPrivateEstablishSessionFunction::OnSessionInitialized(
+ int session_id,
+ api::gcd_private::Status status,
+ const std::vector<api::gcd_private::PairingType>& pairing_types) {
+ results_ = gcd_private::EstablishSession::Results::Create(session_id, status,
+ pairing_types);
+ SendResponse(true);
+}
+
+GcdPrivateStartPairingFunction::GcdPrivateStartPairingFunction() {
+}
+
+GcdPrivateStartPairingFunction::~GcdPrivateStartPairingFunction() {
+}
+
+bool GcdPrivateStartPairingFunction::RunAsync() {
+ scoped_ptr<gcd_private::StartPairing::Params> params =
+ gcd_private::StartPairing::Params::Create(*args_);
+
+ if (!params)
+ return false;
+
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ gcd_api->StartPairing(
+ params->session_id, params->pairing_type,
+ base::Bind(&GcdPrivateStartPairingFunction::OnPairingStarted, this));
+
+ return true;
+}
+
+void GcdPrivateStartPairingFunction::OnPairingStarted(
+ api::gcd_private::Status status) {
+ results_ = gcd_private::StartPairing::Results::Create(status);
+ SendResponse(true);
+}
+
+GcdPrivateConfirmCodeFunction::GcdPrivateConfirmCodeFunction() {
+}
+
+GcdPrivateConfirmCodeFunction::~GcdPrivateConfirmCodeFunction() {
+}
+
+bool GcdPrivateConfirmCodeFunction::RunAsync() {
+ scoped_ptr<gcd_private::ConfirmCode::Params> params =
+ gcd_private::ConfirmCode::Params::Create(*args_);
+
+ if (!params)
+ return false;
+
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ gcd_api->ConfirmCode(
+ params->session_id, params->code,
+ base::Bind(&GcdPrivateConfirmCodeFunction::OnCodeConfirmed, this));
+
+ return true;
+}
+
+void GcdPrivateConfirmCodeFunction::OnCodeConfirmed(
+ api::gcd_private::Status status) {
+ results_ = gcd_private::ConfirmCode::Results::Create(status);
+ SendResponse(true);
+}
+
+GcdPrivateSendMessageFunction::GcdPrivateSendMessageFunction() {
+}
+
+GcdPrivateSendMessageFunction::~GcdPrivateSendMessageFunction() {
+}
+
+bool GcdPrivateSendMessageFunction::RunAsync() {
+ scoped_ptr<gcd_private::PassMessage::Params> params =
+ gcd_private::PassMessage::Params::Create(*args_);
+
+ if (!params)
+ return false;
+
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+
+ gcd_api->SendMessage(
+ params->session_id,
+ params->api,
+ params->input.additional_properties,
+ base::Bind(&GcdPrivateSendMessageFunction::OnMessageSentCallback, this));
+
+ return true;
+}
+
+void GcdPrivateSendMessageFunction::OnMessageSentCallback(
+ api::gcd_private::Status status,
+ const base::DictionaryValue& value) {
+ gcd_private::PassMessage::Results::Response response;
+ response.additional_properties.MergeDictionary(&value);
+
+ results_ = gcd_private::PassMessage::Results::Create(status, response);
+ SendResponse(true);
+}
+
+GcdPrivateTerminateSessionFunction::GcdPrivateTerminateSessionFunction() {
+}
+
+GcdPrivateTerminateSessionFunction::~GcdPrivateTerminateSessionFunction() {
+}
+
+bool GcdPrivateTerminateSessionFunction::RunAsync() {
+ scoped_ptr<gcd_private::TerminateSession::Params> params =
+ gcd_private::TerminateSession::Params::Create(*args_);
+
+ if (!params)
+ return false;
+
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ gcd_api->RemoveSession(params->session_id);
+
+ SendResponse(true);
+ return true;
+}
+
+GcdPrivateGetCommandDefinitionsFunction::
+ GcdPrivateGetCommandDefinitionsFunction() {
+}
+
+GcdPrivateGetCommandDefinitionsFunction::
+ ~GcdPrivateGetCommandDefinitionsFunction() {
+}
+
+GcdPrivateGetPrefetchedWifiNameListFunction::
+ GcdPrivateGetPrefetchedWifiNameListFunction() {
+}
+
+GcdPrivateGetPrefetchedWifiNameListFunction::
+ ~GcdPrivateGetPrefetchedWifiNameListFunction() {
+}
+
+bool GcdPrivateGetPrefetchedWifiNameListFunction::RunSync() {
+ GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+ scoped_ptr<base::ListValue> ssid_list = gcd_api->GetPrefetchedSSIDList();
+
+ SetResult(ssid_list.release());
+
+ return true;
+}
+
+bool GcdPrivateGetCommandDefinitionsFunction::RunAsync() {
+ return false;
+}
+
+GcdPrivateInsertCommandFunction::GcdPrivateInsertCommandFunction() {
+}
+
+GcdPrivateInsertCommandFunction::~GcdPrivateInsertCommandFunction() {
+}
+
+bool GcdPrivateInsertCommandFunction::RunAsync() {
+ return false;
+}
+
+GcdPrivateGetCommandFunction::GcdPrivateGetCommandFunction() {
+}
+
+GcdPrivateGetCommandFunction::~GcdPrivateGetCommandFunction() {
+}
+
+bool GcdPrivateGetCommandFunction::RunAsync() {
+ return false;
+}
+
+GcdPrivateCancelCommandFunction::GcdPrivateCancelCommandFunction() {
+}
+
+GcdPrivateCancelCommandFunction::~GcdPrivateCancelCommandFunction() {
+}
+
+bool GcdPrivateCancelCommandFunction::RunAsync() {
+ return false;
+}
+
+GcdPrivateGetCommandsListFunction::GcdPrivateGetCommandsListFunction() {
+}
+
+GcdPrivateGetCommandsListFunction::~GcdPrivateGetCommandsListFunction() {
+}
+
+bool GcdPrivateGetCommandsListFunction::RunAsync() {
+ return false;
+}
+
} // namespace extensions