Added gcdPrivate.getDeviceInfo function

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/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 83 matching lines @@
 
 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;
+                              const base::DictionaryValue& info)>
+      CreateSessionCallback;
 
   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 CreateSession(const std::string& service_name,
-                     const EstablishSessionCallback& callback);
+                     const CreateSessionCallback& 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);
+  void RemoveSessionDelayed(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);
 
   void OnServiceResolved(int session_id,
-                         const EstablishSessionCallback& callback,
+                         const CreateSessionCallback& callback,
                          scoped_ptr<local_discovery::PrivetHTTPClient> client);
 
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
   void OnWifiPassword(const SuccessCallback& callback,
                       bool success,
                       const std::string& ssid,
                       const std::string& password);
   void StartWifiIfNotStarted();
 #endif
 
@@ skipping 10 matching lines @@
 
   std::map<int, SessionInfo> 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_;
+
+  base::WeakPtrFactory<GcdPrivateAPIImpl> weak_ptr_factory_{this};
+
+  DISALLOW_COPY_AND_ASSIGN(GcdPrivateAPIImpl);
 };
 
 
 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)
@@ skipping 89 matching lines @@
 
 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()));
-
+void GcdPrivateAPIImpl::CreateSession(const std::string& service_name,
+                                      const CreateSessionCallback& callback) {
   int session_id = last_session_id_++;
-  auto& session_data = sessions_[session_id];
-  session_data.session.reset(
-      new local_discovery::PrivetV3Session(http_client.Pass()));
-  session_data.session->Init(base::Bind(callback, session_id));
-}
-
-void GcdPrivateAPIImpl::CreateSession(
-    const std::string& service_name,
-    const EstablishSessionCallback& callback) {
-  int session_id = last_session_id_++;
-
   scoped_ptr<local_discovery::PrivetHTTPAsynchronousFactory> factory(
       local_discovery::PrivetHTTPAsynchronousFactory::CreateInstance(
           browser_context_->GetRequestContext()));
   auto& session_data = sessions_[session_id];
   session_data.http_resolution.reset(
       factory->CreatePrivetHTTP(service_name).release());
   session_data.http_resolution->Start(
       base::Bind(&GcdPrivateAPIImpl::OnServiceResolved, base::Unretained(this),
                  session_id, callback));
 }
 
 void GcdPrivateAPIImpl::OnServiceResolved(
     int session_id,
-    const EstablishSessionCallback& callback,
+    const CreateSessionCallback& callback,
     scoped_ptr<local_discovery::PrivetHTTPClient> client) {
   if (!client) {
     return callback.Run(session_id, gcd_private::STATUS_SERVICERESOLUTIONERROR,
-                        std::vector<gcd_private::PairingType>());
+                        base::DictionaryValue());
   }
   auto& session_data = sessions_[session_id];
   session_data.session.reset(
       new local_discovery::PrivetV3Session(client.Pass()));
   session_data.session->Init(base::Bind(callback, session_id));
 }
 
 void GcdPrivateAPIImpl::StartPairing(int session_id,
                                      api::gcd_private::PairingType pairing_type,
                                      const SessionCallback& callback) {
@@ skipping 95 matching lines @@
     wifi_manager_->Start();
   }
 }
 
 #endif
 
 void GcdPrivateAPIImpl::RemoveSession(int session_id) {
   sessions_.erase(session_id);
 }
 
+void GcdPrivateAPIImpl::RemoveSessionDelayed(int session_id) {
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::Bind(&GcdPrivateAPIImpl::RemoveSession,
+               weak_ptr_factory_.GetWeakPtr(), 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
@@ skipping 143 matching lines @@
   return true;
 }
 
 void GcdPrivatePrefetchWifiPasswordFunction::OnResponse(bool response) {
   scoped_ptr<base::FundamentalValue> response_value(
       new base::FundamentalValue(response));
   SetResult(response_value.release());
   SendResponse(true);
 }
 
+GcdPrivateGetDeviceInfoFunction::GcdPrivateGetDeviceInfoFunction() {
+}
+
+GcdPrivateGetDeviceInfoFunction::~GcdPrivateGetDeviceInfoFunction() {
+}
+
+bool GcdPrivateGetDeviceInfoFunction::RunAsync() {
+  scoped_ptr<gcd_private::CreateSession::Params> params =
+      gcd_private::CreateSession::Params::Create(*args_);
+
+  if (!params)
+    return false;
+
+  GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+
+  GcdPrivateAPIImpl::CreateSessionCallback callback =
+      base::Bind(&GcdPrivateGetDeviceInfoFunction::OnSessionInitialized, this);
+  gcd_api->CreateSession(params->service_name, callback);
+
+  return true;
+}
+
+void GcdPrivateGetDeviceInfoFunction::OnSessionInitialized(
+    int session_id,
+    api::gcd_private::Status status,
+    const base::DictionaryValue& info) {
+  gcd_private::GetDeviceInfo::Results::DeviceInfo device_info;
+  device_info.additional_properties.MergeDictionary(&info);
+
+  results_ = gcd_private::GetDeviceInfo::Results::Create(status, device_info);
+  SendResponse(true);
+
+  GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
+  gcd_api->RemoveSessionDelayed(session_id);
+}
+
 GcdPrivateCreateSessionFunction::GcdPrivateCreateSessionFunction() {
 }
 
 GcdPrivateCreateSessionFunction::~GcdPrivateCreateSessionFunction() {
 }
 
 bool GcdPrivateCreateSessionFunction::RunAsync() {
   scoped_ptr<gcd_private::CreateSession::Params> params =
       gcd_private::CreateSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
-  GcdPrivateAPIImpl::EstablishSessionCallback callback =
+  GcdPrivateAPIImpl::CreateSessionCallback callback =
       base::Bind(&GcdPrivateCreateSessionFunction::OnSessionInitialized, this);
   gcd_api->CreateSession(params->service_name, callback);
 
   return true;
 }
 
 void GcdPrivateCreateSessionFunction::OnSessionInitialized(
     int session_id,
     api::gcd_private::Status status,
-    const std::vector<api::gcd_private::PairingType>& pairing_types) {
+    const base::DictionaryValue& info) {
+  std::vector<api::gcd_private::PairingType> pairing_types;
+
+  // TODO(vitalybuka): Remove this parsing and |pairing_types| from callback.
+  if (status == gcd_private::STATUS_SUCCESS) {
+    const base::ListValue* pairing = nullptr;
+    if (info.GetList("authentication.pairing", &pairing)) {
+      for (const base::Value* value : *pairing) {
+        std::string pairing_string;
+        if (value->GetAsString(&pairing_string)) {
+          api::gcd_private::PairingType pairing_type =
+              api::gcd_private::ParsePairingType(pairing_string);
+          if (pairing_type != api::gcd_private::PAIRING_TYPE_NONE)
+            pairing_types.push_back(pairing_type);
+        }
+      }
+    } else {
+      status = gcd_private::STATUS_SESSIONERROR;
+    }
+  }
+
   results_ = gcd_private::CreateSession::Results::Create(session_id, status,
                                                          pairing_types);
   SendResponse(true);
 }
 
 GcdPrivateStartPairingFunction::GcdPrivateStartPairingFunction() {
 }
 
 GcdPrivateStartPairingFunction::~GcdPrivateStartPairingFunction() {
 }
@@ skipping 168 matching lines @@
 }
 
 GcdPrivateGetCommandsListFunction::~GcdPrivateGetCommandsListFunction() {
 }
 
 bool GcdPrivateGetCommandsListFunction::RunAsync() {
   return false;
 }
 
 }  // namespace extensions