Use persistent map of privet tokens for PrivetURLFetcher

chrome/browser/local_discovery/privet_url_fetcher.cc

 // Copyright 2013 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/privet_url_fetcher.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
 
 namespace local_discovery {
 
 namespace {

[Vitaly Buka (NO REVIEWS), 2014/02/14 22:57:46]

empty line after { and before } below

[Noam Samuel, 2014/02/14 23:26:12]

Done.

+typedef std::map<std::string, std::string> TokenMap;
+
 const char kXPrivetTokenHeaderPrefix[] = "X-Privet-Token: ";
 const char kXPrivetEmptyToken[] = "\"\"";
 const int kPrivetMaxRetries = 20;
 const int kPrivetTimeoutOnError = 5;
+
+TokenMap* g_token_map = NULL;
 }
 
 void PrivetURLFetcher::Delegate::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const TokenCallback& callback) {
   OnError(fetcher, TOKEN_ERROR);
 }
 
 PrivetURLFetcher::PrivetURLFetcher(
-    const std::string& token,
     const GURL& url,
     net::URLFetcher::RequestType request_type,
     net::URLRequestContextGetter* request_context,
     PrivetURLFetcher::Delegate* delegate)
-    : privet_access_token_(token), url_(url), request_type_(request_type),
+    :  url_(url), request_type_(request_type),
       request_context_(request_context), delegate_(delegate),
       do_not_retry_on_transient_error_(false), allow_empty_privet_token_(false),
       tries_(0), weak_factory_(this) {
 }
 
 PrivetURLFetcher::~PrivetURLFetcher() {
 }
 
+// static
+void PrivetURLFetcher::SetTokenForHost(const  std::string& host,

[Vitaly Buka (NO REVIEWS), 2014/02/14 22:57:46]

double white space

[Noam Samuel, 2014/02/14 23:26:12]

Done.

+                                       const std::string& token) {
+  if (!g_token_map) g_token_map = new TokenMap();

[Vitaly Buka (NO REVIEWS), 2014/02/14 22:57:46]

Can you please use Singleton for g_tocket_map?

[Noam Samuel, 2014/02/14 23:26:12]

Done.

+  (*g_token_map)[host] = token;
+}
+
+// static
+void PrivetURLFetcher::ResetTokenMapForTests() {
+  if (g_token_map) delete g_token_map;
+  g_token_map = NULL;
+}
+
 void PrivetURLFetcher::DoNotRetryOnTransientError() {
   do_not_retry_on_transient_error_ = true;
 }
 
 void PrivetURLFetcher::AllowEmptyPrivetToken() {
   allow_empty_privet_token_ = true;
 }
 
+std::string PrivetURLFetcher::GetPrivetAccessToken() {
+  if (!g_token_map) return std::string();
+  TokenMap::iterator found = g_token_map->find(GetHostString());
+  if (found != g_token_map->end()) {
+    return found->second;
+  } else {
+    return std::string();
+  }
+}
+
+std::string PrivetURLFetcher::GetHostString() {
+  return url_.GetOrigin().spec();
+}
+
 void PrivetURLFetcher::Try() {
   tries_++;
   if (tries_ < kPrivetMaxRetries) {
-    std::string token = privet_access_token_;
+    std::string token = GetPrivetAccessToken();
 
     if (token.empty())
       token = kXPrivetEmptyToken;
 
     url_fetcher_.reset(net::URLFetcher::Create(url_, request_type_, this));
     url_fetcher_->SetRequestContext(request_context_);
     url_fetcher_->AddExtraRequestHeader(std::string(kXPrivetTokenHeaderPrefix) +
                                         token);
 
     // URLFetcher requires us to set upload data for POST requests.
@@ skipping 13 matching lines @@
 
     url_fetcher_->Start();
   } else {
     delegate_->OnError(this, RETRY_ERROR);
   }
 }
 
 void PrivetURLFetcher::Start() {
   DCHECK_EQ(tries_, 0);  // We haven't called |Start()| yet.
 
-  if (privet_access_token_.empty() && !allow_empty_privet_token_) {
+  std::string privet_access_token = GetPrivetAccessToken();
+  if (privet_access_token.empty() && !allow_empty_privet_token_) {
     RequestTokenRefresh();
   } else {
     Try();
   }
 }
 
 void PrivetURLFetcher::SetUploadData(const std::string& upload_content_type,
                                      const std::string& upload_data) {
   DCHECK(upload_file_path_.empty());
   upload_content_type_ = upload_content_type;
@@ skipping 85 matching lines @@
 void PrivetURLFetcher::RequestTokenRefresh() {
   delegate_->OnNeedPrivetToken(
       this,
       base::Bind(&PrivetURLFetcher::RefreshToken, weak_factory_.GetWeakPtr()));
 }
 
 void PrivetURLFetcher::RefreshToken(const std::string& token) {
   if (token.empty()) {
     delegate_->OnError(this, TOKEN_ERROR);
   } else {
-    privet_access_token_ = token;
+    SetTokenForHost(GetHostString(), token);
     Try();
   }
 }
 
 bool PrivetURLFetcher::PrivetErrorTransient(const std::string& error) {
   return (error == kPrivetErrorDeviceBusy) ||
          (error == kPrivetErrorPendingUserAction) ||
          (error == kPrivetErrorPrinterBusy);
 }
 
-PrivetURLFetcherFactory::PrivetURLFetcherFactory(
-    net::URLRequestContextGetter* request_context)
-    : request_context_(request_context) {
-}
-
-PrivetURLFetcherFactory::~PrivetURLFetcherFactory() {
-}
-
-scoped_ptr<PrivetURLFetcher> PrivetURLFetcherFactory::CreateURLFetcher(
-    const GURL& url, net::URLFetcher::RequestType request_type,
-    PrivetURLFetcher::Delegate* delegate) const {
-  return scoped_ptr<PrivetURLFetcher>(
-      new PrivetURLFetcher(token_, url, request_type, request_context_.get(),
-                           delegate));
-}
-
 }  // namespace local_discovery