chrome.gcdPrivate allows app to choose pairing method.

chrome/browser/local_discovery/privetv3_session.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/local_discovery/privetv3_session.h"
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/local_discovery/privet_http.h"
@@ skipping 12 matching lines @@
   GURL::Replacements replacements;
   replacements.SetPathStr(path);
   return url.ReplaceComponents(replacements);
 }
 
 }  // namespace
 
 class PrivetV3Session::FetcherDelegate : public PrivetURLFetcher::Delegate {
  public:
   FetcherDelegate(const base::WeakPtr<PrivetV3Session>& session,
-                  Request* request);
+                  const PrivetV3Session::MessageCallback& callback);
   ~FetcherDelegate() override;
 
   // PrivetURLFetcher::Delegate methods.
   void OnNeedPrivetToken(
       PrivetURLFetcher* fetcher,
       const PrivetURLFetcher::TokenCallback& callback) override;
   void OnError(PrivetURLFetcher* fetcher,
                PrivetURLFetcher::ErrorType error) override;
   void OnParsedJson(PrivetURLFetcher* fetcher,
                     const base::DictionaryValue& value,
                     bool has_error) override;
 
  private:
   friend class PrivetV3Session;
+  void DeleteThis();
+
   scoped_ptr<PrivetURLFetcher> url_fetcher_;
   base::WeakPtr<PrivetV3Session> session_;
-  Request* request_;
+  MessageCallback callback_;
 };
 
 PrivetV3Session::FetcherDelegate::FetcherDelegate(
     const base::WeakPtr<PrivetV3Session>& session,
-    Request* request)
-    : session_(session), request_(request) {
+    const PrivetV3Session::MessageCallback& callback)
+    : session_(session), callback_(callback) {
 }
 
 PrivetV3Session::FetcherDelegate::~FetcherDelegate() {
 }
 
 void PrivetV3Session::FetcherDelegate::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const PrivetURLFetcher::TokenCallback& callback) {
   if (session_)
     session_->client_->RefreshPrivetToken(callback);
 }
 
 void PrivetV3Session::FetcherDelegate::OnError(
     PrivetURLFetcher* fetcher,
     PrivetURLFetcher::ErrorType error) {
-  request_->OnError();
+  if (session_) {
+    callback_.Run(Result::STATUS_CONNECTIONERROR, base::DictionaryValue());
+    DeleteThis();
+  }
 }
 
 void PrivetV3Session::FetcherDelegate::OnParsedJson(
     PrivetURLFetcher* fetcher,
     const base::DictionaryValue& value,
     bool has_error) {
-  request_->OnParsedJson(value, has_error);
+  if (session_) {
+    callback_.Run(
+        has_error ? Result::STATUS_SETUPERROR : Result::STATUS_SUCCESS, value);
+    DeleteThis();
+  }
 }
 
-PrivetV3Session::Delegate::~Delegate() {
+void PrivetV3Session::FetcherDelegate::DeleteThis() {
+  session_->fetchers_.erase(
+      std::find(session_->fetchers_.begin(), session_->fetchers_.end(), this));
 }
 
 PrivetV3Session::Request::Request() {
 }
 
 PrivetV3Session::Request::~Request() {
 }
 
-PrivetV3Session::PrivetV3Session(scoped_ptr<PrivetHTTPClient> client,
-                                 Delegate* delegate)
-    : delegate_(delegate),
-      client_(client.Pass()),
-      code_confirmed_(false),
-      weak_ptr_factory_(this) {
+PrivetV3Session::PrivetV3Session(scoped_ptr<PrivetHTTPClient> client)
+    : client_(client.Pass()), code_confirmed_(false), weak_ptr_factory_(this) {
 }
 
 PrivetV3Session::~PrivetV3Session() {
 }
 
-void PrivetV3Session::Start() {
+void PrivetV3Session::Init(const InitCallback& callback) {
+  // TODO: call /info.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&PrivetV3Session::ConfirmFakeCode,
-                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&PrivetV3Session::RunCallback,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Bind(callback,
+                            Result::STATUS_SUCCESS,
+                            std::vector<PairingType>(
+                                1, PairingType::PAIRING_TYPE_EMBEDDEDCODE))),
       base::TimeDelta::FromSeconds(1));
 }
 
-void PrivetV3Session::ConfirmCode(const std::string& code) {
+void PrivetV3Session::StartPairing(PairingType pairing_type,
+                                   const ResultCallback& callback) {
+  // TODO: call /privet/v3/pairing/start.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&PrivetV3Session::RunCallback,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Bind(callback, Result::STATUS_SUCCESS)),
+      base::TimeDelta::FromSeconds(1));
+}
+
+void PrivetV3Session::ConfirmCode(const std::string& code,
+                                  const ResultCallback& callback) {
+  // TODO: call /privet/v3/pairing/confirm.
   if (code == kStubPrivetCode) {
     code_confirmed_ = true;
-    delegate_->OnSessionStatus(extensions::api::gcd_private::STATUS_SUCCESS);
+    callback.Run(Result::STATUS_SUCCESS);
   } else {
-    delegate_->OnSessionStatus(
-        extensions::api::gcd_private::STATUS_BADCONFIRMATIONCODEERROR);
+    callback.Run(Result::STATUS_BADPAIRINGCODEERROR);
   }
 }
 
-void PrivetV3Session::StartRequest(Request* request) {
-  if (!code_confirmed_) {
-    delegate_->OnSessionStatus(
-        extensions::api::gcd_private::STATUS_SESSIONERROR);
-    return;
-  }
+void PrivetV3Session::SendMessage(const std::string& api,
+                                  const base::DictionaryValue& input,
+                                  const MessageCallback& callback) {
+  if (!code_confirmed_)
+    return callback.Run(Result::STATUS_SESSIONERROR, base::DictionaryValue());
 
-  request->fetcher_delegate_.reset(
-      new FetcherDelegate(weak_ptr_factory_.GetWeakPtr(), request));
+  FetcherDelegate* fetcher_delegate(
+      new FetcherDelegate(weak_ptr_factory_.GetWeakPtr(), callback));
+  fetchers_.push_back(fetcher_delegate);
 
-  scoped_ptr<PrivetURLFetcher> url_fetcher =
-      client_->CreateURLFetcher(CreatePrivetURL(request->GetName()),
-                                net::URLFetcher::POST,
-                                request->fetcher_delegate_.get());
+  scoped_ptr<PrivetURLFetcher> url_fetcher(client_->CreateURLFetcher(
+      CreatePrivetURL(api), net::URLFetcher::POST, fetcher_delegate));
+
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      &request->GetInput(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      &input, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   url_fetcher->SetUploadData(cloud_print::kContentTypeJSON, json);
 
-  request->fetcher_delegate_->url_fetcher_ = url_fetcher.Pass();
-  request->fetcher_delegate_->url_fetcher_->V3Mode();
-  request->fetcher_delegate_->url_fetcher_->Start();
+  fetcher_delegate->url_fetcher_ = url_fetcher.Pass();
+  fetcher_delegate->url_fetcher_->V3Mode();
+  fetcher_delegate->url_fetcher_->Start();
 }
 
-void PrivetV3Session::ConfirmFakeCode() {
-  delegate_->OnSetupConfirmationNeeded(
-      kStubPrivetCode,
-      extensions::api::gcd_private::CONFIRMATION_TYPE_DISPLAYCODE);
+void PrivetV3Session::RunCallback(const base::Closure& callback) {
+  callback.Run();
 }
 
 }  // namespace local_discovery