chrome/browser/local_discovery/privetv3_session.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/local_discovery/privetv3_session.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "chrome/browser/local_discovery/privet_http.h"
  11 #include "chrome/common/cloud_print/cloud_print_constants.h"
  12
  13 namespace local_discovery {
  14
  15 namespace {
  16
  17 const char kUrlPlaceHolder[] = "http://host/";
  18
  19 const char kStubPrivetCode[] = "1234";
  20
  21 GURL CreatePrivetURL(const std::string& path) {
  22   GURL url(kUrlPlaceHolder);
  23   GURL::Replacements replacements;
  24   replacements.SetPathStr(path);
  25   return url.ReplaceComponents(replacements);
  26 }
  27
  28 }  // namespace
  29
  30 class PrivetV3Session::FetcherDelegate : public PrivetURLFetcher::Delegate {
  31  public:
  32   FetcherDelegate(const base::WeakPtr<PrivetV3Session>& session,
  33                   const PrivetV3Session::MessageCallback& callback);
  34   ~FetcherDelegate() override;
  35
  36   // PrivetURLFetcher::Delegate methods.
  37   void OnNeedPrivetToken(
  38       PrivetURLFetcher* fetcher,
  39       const PrivetURLFetcher::TokenCallback& callback) override;
  40   void OnError(PrivetURLFetcher* fetcher,
  41                PrivetURLFetcher::ErrorType error) override;
  42   void OnParsedJson(PrivetURLFetcher* fetcher,
  43                     const base::DictionaryValue& value,
  44                     bool has_error) override;
  45
  46  private:
  47   friend class PrivetV3Session;
  48   void DeleteThis();
  49
  50   scoped_ptr<PrivetURLFetcher> url_fetcher_;
  51   base::WeakPtr<PrivetV3Session> session_;
  52   MessageCallback callback_;
  53 };
  54
  55 PrivetV3Session::FetcherDelegate::FetcherDelegate(
  56     const base::WeakPtr<PrivetV3Session>& session,
  57     const PrivetV3Session::MessageCallback& callback)
  58     : session_(session), callback_(callback) {
  59 }
  60
  61 PrivetV3Session::FetcherDelegate::~FetcherDelegate() {
  62 }
  63
  64 void PrivetV3Session::FetcherDelegate::OnNeedPrivetToken(
  65     PrivetURLFetcher* fetcher,
  66     const PrivetURLFetcher::TokenCallback& callback) {
  67   NOTREACHED();
  68 }
  69
  70 void PrivetV3Session::FetcherDelegate::OnError(
  71     PrivetURLFetcher* fetcher,
  72     PrivetURLFetcher::ErrorType error) {
  73   if (session_) {
  74     DeleteThis();
  75     callback_.Run(Result::STATUS_CONNECTIONERROR, base::DictionaryValue());
  76   }
  77 }
  78
  79 void PrivetV3Session::FetcherDelegate::OnParsedJson(
  80     PrivetURLFetcher* fetcher,
  81     const base::DictionaryValue& value,
  82     bool has_error) {
  83   if (session_) {
  84     DeleteThis();
  85     callback_.Run(
  86         has_error ? Result::STATUS_DEVICEERROR : Result::STATUS_SUCCESS, value);
  87   }
  88 }
  89
  90 void PrivetV3Session::FetcherDelegate::DeleteThis() {
  91   base::MessageLoop::current()->PostTask(
  92       FROM_HERE, base::Bind(&PrivetV3Session::DeleteFetcher, session_,
  93                             base::Unretained(this)));
  94 }
  95
  96 PrivetV3Session::Request::Request() {
  97 }
  98
  99 PrivetV3Session::Request::~Request() {
 100 }
 101
 102 PrivetV3Session::PrivetV3Session(scoped_ptr<PrivetHTTPClient> client)
 103     : client_(client.Pass()), code_confirmed_(false), weak_ptr_factory_(this) {
 104 }
 105
 106 PrivetV3Session::~PrivetV3Session() {
 107 }
 108
 109 void PrivetV3Session::Init(const InitCallback& callback) {
 110   // TODO: call /info.
 111   base::MessageLoop::current()->PostDelayedTask(
 112       FROM_HERE,
 113       base::Bind(&PrivetV3Session::RunCallback, weak_ptr_factory_.GetWeakPtr(),
 114                  base::Bind(callback, Result::STATUS_SUCCESS,
 115                             std::vector<PairingType>(
 116                                 1, PairingType::PAIRING_TYPE_EMBEDDEDCODE))),
 117       base::TimeDelta::FromSeconds(1));
 118 }
 119
 120 void PrivetV3Session::StartPairing(PairingType pairing_type,
 121                                    const ResultCallback& callback) {
 122   // TODO: call /privet/v3/pairing/start.
 123   base::MessageLoop::current()->PostDelayedTask(
 124       FROM_HERE,
 125       base::Bind(&PrivetV3Session::RunCallback, weak_ptr_factory_.GetWeakPtr(),
 126                  base::Bind(callback, Result::STATUS_SUCCESS)),
 127       base::TimeDelta::FromSeconds(1));
 128 }
 129
 130 void PrivetV3Session::ConfirmCode(const std::string& code,
 131                                   const ResultCallback& callback) {
 132   // TODO: call /privet/v3/pairing/confirm.
 133   if (code == kStubPrivetCode) {
 134     code_confirmed_ = true;
 135     callback.Run(Result::STATUS_SUCCESS);
 136   } else {
 137     callback.Run(Result::STATUS_BADPAIRINGCODEERROR);
 138   }
 139 }
 140
 141 void PrivetV3Session::SendMessage(const std::string& api,
 142                                   const base::DictionaryValue& input,
 143                                   const MessageCallback& callback) {
 144   if (!code_confirmed_)
 145     return callback.Run(Result::STATUS_SESSIONERROR, base::DictionaryValue());
 146
 147   FetcherDelegate* fetcher_delegate(
 148       new FetcherDelegate(weak_ptr_factory_.GetWeakPtr(), callback));
 149   fetchers_.push_back(fetcher_delegate);
 150
 151   scoped_ptr<PrivetURLFetcher> url_fetcher(client_->CreateURLFetcher(
 152       CreatePrivetURL(api), net::URLFetcher::POST, fetcher_delegate));
 153
 154   std::string json;
 155   base::JSONWriter::WriteWithOptions(
 156       &input, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
 157   url_fetcher->SetUploadData(cloud_print::kContentTypeJSON, json);
 158
 159   fetcher_delegate->url_fetcher_ = url_fetcher.Pass();
 160   fetcher_delegate->url_fetcher_->V3Mode();
 161   fetcher_delegate->url_fetcher_->Start();
 162 }
 163
 164 void PrivetV3Session::RunCallback(const base::Closure& callback) {
 165   callback.Run();
 166 }
 167
 168 void PrivetV3Session::DeleteFetcher(const FetcherDelegate* fetcher) {
 169   fetchers_.erase(std::find(fetchers_.begin(), fetchers_.end(), fetcher));
 170 }
 171
 172 }  // namespace local_discovery