Use persistent map of privet tokens for PrivetURLFetcher

chrome/browser/local_discovery/privet_http_impl.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_http_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 91 matching lines @@
 }
 
 void PrivetInfoOperationImpl::OnError(PrivetURLFetcher* fetcher,
                                       PrivetURLFetcher::ErrorType error) {
   callback_.Run(NULL);
 }
 
 void PrivetInfoOperationImpl::OnParsedJson(PrivetURLFetcher* fetcher,
                                            const base::DictionaryValue* value,
                                            bool has_error) {
-  if (!has_error)
-    privet_client_->CacheInfo(value);
   callback_.Run(value);
 }
 
 PrivetRegisterOperationImpl::PrivetRegisterOperationImpl(
     PrivetHTTPClientImpl* privet_client,
     const std::string& user,
     PrivetRegisterOperation::Delegate* delegate)
     : user_(user), delegate_(delegate), privet_client_(privet_client),
       ongoing_(false) {
 }
@@ skipping 580 matching lines @@
 void PrivetLocalPrintOperationImpl::SetPWGRasterConverterForTesting(
     scoped_ptr<PWGRasterConverter> pwg_raster_converter) {
   pwg_raster_converter_ = pwg_raster_converter.Pass();
 }
 
 PrivetHTTPClientImpl::PrivetHTTPClientImpl(
     const std::string& name,
     const net::HostPortPair& host_port,
     net::URLRequestContextGetter* request_context)
     : name_(name),
-      fetcher_factory_(request_context),
+      request_context_(request_context),
       host_port_(host_port) {
 }
 
 PrivetHTTPClientImpl::~PrivetHTTPClientImpl() {
 }
 
-const base::DictionaryValue* PrivetHTTPClientImpl::GetCachedInfo() const {
-  return cached_info_.get();
-}
-
 scoped_ptr<PrivetRegisterOperation>
 PrivetHTTPClientImpl::CreateRegisterOperation(
     const std::string& user,
     PrivetRegisterOperation::Delegate* delegate) {
   return scoped_ptr<PrivetRegisterOperation>(
       new PrivetRegisterOperationImpl(this, user, delegate));
 }
 
 scoped_ptr<PrivetJSONOperation> PrivetHTTPClientImpl::CreateInfoOperation(
     const PrivetJSONOperation::ResultCallback& callback) {
@@ skipping 30 matching lines @@
   return name_;
 }
 
 scoped_ptr<PrivetURLFetcher> PrivetHTTPClientImpl::CreateURLFetcher(
     const GURL& url, net::URLFetcher::RequestType request_type,
     PrivetURLFetcher::Delegate* delegate) const {
   GURL::Replacements replacements;
   replacements.SetHostStr(host_port_.host());
   std::string port(base::IntToString(host_port_.port()));  // Keep string alive.
   replacements.SetPortStr(port);
-  return fetcher_factory_.CreateURLFetcher(url.ReplaceComponents(replacements),
-                                           request_type, delegate);
+  return scoped_ptr<PrivetURLFetcher>(
+      new PrivetURLFetcher(url.ReplaceComponents(replacements), request_type,
+                           request_context_.get(), delegate));
 }
 
-void PrivetHTTPClientImpl::CacheInfo(const base::DictionaryValue* cached_info) {
-  cached_info_.reset(cached_info->DeepCopy());
-  std::string token;
-  if (cached_info_->GetString(kPrivetInfoKeyToken, &token)) {
-    fetcher_factory_.set_token(token);
-  }
-}
-
-bool PrivetHTTPClientImpl::HasToken() const {
-  return fetcher_factory_.get_token() != "";
-};
-
 void PrivetHTTPClientImpl::RefreshPrivetToken(
     const PrivetURLFetcher::TokenCallback& callback) {
   token_callbacks_.push_back(callback);
 
   if (!info_operation_) {
     info_operation_ = CreateInfoOperation(
         base::Bind(&PrivetHTTPClientImpl::OnPrivetInfoDone,
                    base::Unretained(this)));
     info_operation_->Start();
   }
@@ skipping 13 matching lines @@
   TokenCallbackVector token_callbacks;
   token_callbacks_.swap(token_callbacks);
 
   for (TokenCallbackVector::iterator i = token_callbacks.begin();
        i != token_callbacks.end(); i++) {
     i->Run(token);
   }
 }
 
 }  // namespace local_discovery