API change to allow sticker authentication for devices

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 106 matching lines @@
   virtual ~GcdPrivateAPIImpl();
 
   static GcdPrivateAPIImpl* Get(content::BrowserContext* context);
 
   bool QueryForDevices();
 
   void EstablishSession(const std::string& ip_address,
                         int port,
                         ConfirmationCodeCallback callback);
 
-  void ConfirmCode(int session_id, SessionEstablishedCallback callback);
+  void ConfirmCode(int session_id,
+                   const std::string& code,
+                   SessionEstablishedCallback callback);
 
   void SendMessage(int session_id,
                    const std::string& api,
                    const base::DictionaryValue& input,
                    MessageResponseCallback callback);
 
   void RequestWifiPassword(const std::string& ssid,
                            const SuccessCallback& callback);
 
   void RemoveSession(int session_id);
@@ skipping 84 matching lines @@
       ConfirmationCodeCallback;
 
   GcdPrivateSessionHolder(const std::string& ip_address,
                           int port,
                           net::URLRequestContextGetter* request_context);
   virtual ~GcdPrivateSessionHolder();
 
   void Start(const ConfirmationCodeCallback& callback);
 
   void ConfirmCode(
+      const std::string& code,
       const GcdPrivateAPIImpl::SessionEstablishedCallback& callback);
 
   void SendMessage(const std::string& api,
                    const base::DictionaryValue& input,
                    GcdPrivateAPIImpl::MessageResponseCallback callback);
 
   void DeleteRequest(GcdPrivateRequest* request);
 
  private:
   // local_discovery::PrivetV3Session::Delegate implementation.
   virtual void OnSetupConfirmationNeeded(
-      const std::string& confirmation_code) OVERRIDE;
-  virtual void OnSessionEstablished() OVERRIDE;
-  virtual void OnCannotEstablishSession() OVERRIDE;
+      const std::string& confirmation_code,
+      api::gcd_private::ConfirmationType confirmation_type) OVERRIDE;
+  virtual void OnSessionStatus(api::gcd_private::Status status) OVERRIDE;
 
   scoped_ptr<local_discovery::PrivetHTTPClient> http_client_;
   scoped_ptr<local_discovery::PrivetV3Session> privet_session_;
   typedef ScopedVector<GcdPrivateRequest> RequestVector;
   RequestVector requests_;
 
   ConfirmationCodeCallback confirm_callback_;
   GcdPrivateAPIImpl::SessionEstablishedCallback session_established_callback_;
 };
 
@@ skipping 108 matching lines @@
                                          ConfirmationCodeCallback callback) {
   int session_id = last_session_id_++;
   linked_ptr<GcdPrivateSessionHolder> session_handler(
       new GcdPrivateSessionHolder(
           ip_address, port, browser_context_->GetRequestContext()));
   sessions_[session_id] = session_handler;
   session_handler->Start(base::Bind(callback, session_id));
 }
 
 void GcdPrivateAPIImpl::ConfirmCode(int session_id,
+                                    const std::string& code,
                                     SessionEstablishedCallback callback) {
   GCDSessionMap::iterator found = sessions_.find(session_id);
 
   if (found == sessions_.end()) {
     callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR);
     return;
   }
 
-  found->second->ConfirmCode(callback);
+  found->second->ConfirmCode(code, callback);
 }
 
 void GcdPrivateAPIImpl::SendMessage(int session_id,
                                     const std::string& api,
                                     const base::DictionaryValue& input,
                                     MessageResponseCallback callback) {
   const base::DictionaryValue* input_actual = &input;
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
   scoped_ptr<base::DictionaryValue> input_cloned;
 
@@ skipping 151 matching lines @@
 
 void GcdPrivateSessionHolder::Start(const ConfirmationCodeCallback& callback) {
   confirm_callback_ = callback;
 
   privet_session_.reset(
       new local_discovery::PrivetV3Session(http_client_.Pass(), this));
   privet_session_->Start();
 }
 
 void GcdPrivateSessionHolder::ConfirmCode(
+    const std::string& code,
     const GcdPrivateAPIImpl::SessionEstablishedCallback& callback) {
   session_established_callback_ = callback;
-  privet_session_->ConfirmCode();
+  privet_session_->ConfirmCode(code);
 }
 
 void GcdPrivateSessionHolder::SendMessage(
     const std::string& api,
     const base::DictionaryValue& input,
     GcdPrivateAPIImpl::MessageResponseCallback callback) {
   GcdPrivateRequest* request =
       new GcdPrivateRequest(api, input, callback, this);
   requests_.push_back(request);
   privet_session_->StartRequest(request);
 }
 
 void GcdPrivateSessionHolder::DeleteRequest(GcdPrivateRequest* request) {
   // TODO(noamsml): Does this need to be optimized?
   for (RequestVector::iterator i = requests_.begin(); i != requests_.end();
        i++) {
     if (*i == request) {
       requests_.erase(i);
       break;
     }
   }
 }
 
 void GcdPrivateSessionHolder::OnSetupConfirmationNeeded(
-    const std::string& confirmation_code) {
-  confirm_callback_.Run(gcd_private::STATUS_SUCCESS,
-                        confirmation_code,
-                        gcd_private::CONFIRMATION_TYPE_DISPLAYCODE);
+    const std::string& confirmation_code,
+    gcd_private::ConfirmationType confirmation_type) {
+  confirm_callback_.Run(
+      gcd_private::STATUS_SUCCESS, confirmation_code, confirmation_type);
 
   confirm_callback_.Reset();
 }
 
-void GcdPrivateSessionHolder::OnSessionEstablished() {
-  session_established_callback_.Run(gcd_private::STATUS_SUCCESS);
+void GcdPrivateSessionHolder::OnSessionStatus(gcd_private::Status status) {
+  session_established_callback_.Run(status);
 
   session_established_callback_.Reset();
 }
-
-void GcdPrivateSessionHolder::OnCannotEstablishSession() {
-  session_established_callback_.Run(gcd_private::STATUS_SESSIONERROR);
-
-  session_established_callback_.Reset();
-}
 
 GcdPrivateAPI::GcdPrivateAPI(content::BrowserContext* context)
     : impl_(new GcdPrivateAPIImpl(context)) {
 }
 
 GcdPrivateAPI::~GcdPrivateAPI() {
 }
 
 // static
 BrowserContextKeyedAPIFactory<GcdPrivateAPI>*
@@ skipping 157 matching lines @@
                  this));
 
   return true;
 }
 
 void GcdPrivateEstablishSessionFunction::OnConfirmCodeCallback(
     int session_id,
     gcd_private::Status status,
     const std::string& confirm_code,
     gcd_private::ConfirmationType confirmation_type) {
-  results_ = gcd_private::EstablishSession::Results::Create(
-      session_id, status, confirm_code, confirmation_type);
+  gcd_private::ConfirmationInfo info;
+
+  info.type = confirmation_type;
+  if (!confirm_code.empty()) {
+    info.code.reset(new std::string(confirm_code));
+  }
+
+  results_ =
+      gcd_private::EstablishSession::Results::Create(session_id, status, info);
   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::OnSessionEstablishedCallback,
                  this));
 
   return true;
 }
 
 void GcdPrivateConfirmCodeFunction::OnSessionEstablishedCallback(
     api::gcd_private::Status status) {
   results_ = gcd_private::ConfirmCode::Results::Create(status);
   SendResponse(true);
@@ skipping 119 matching lines @@
 }
 
 GcdPrivateGetCommandsListFunction::~GcdPrivateGetCommandsListFunction() {
 }
 
 bool GcdPrivateGetCommandsListFunction::RunAsync() {
   return false;
 }
 
 }  // namespace extensions