Send an empty Privet token with /privet/info always

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"
@@ skipping 54 matching lines @@
 PrivetURLFetcher::PrivetURLFetcher(
     const GURL& url,
     net::URLFetcher::RequestType request_type,
     net::URLRequestContextGetter* request_context,
     PrivetURLFetcher::Delegate* delegate)
     : url_(url),
       request_type_(request_type),
       request_context_(request_context),
       delegate_(delegate),
       do_not_retry_on_transient_error_(false),
-      allow_empty_privet_token_(false),
+      send_empty_privet_token_(false),
       has_byte_range_(false),
       make_response_file_(false),
       byte_range_start_(0),
       byte_range_end_(0),
       tries_(0),
       weak_factory_(this) {}
 
 PrivetURLFetcher::~PrivetURLFetcher() {
 }
 
 // static
 void PrivetURLFetcher::SetTokenForHost(const std::string& host,
                                        const std::string& token) {
   TokenMapHolder::GetInstance()->map[host] = token;
 }
 
 // static
 void PrivetURLFetcher::ResetTokenMapForTests() {
   TokenMapHolder::GetInstance()->map.clear();
 }
 
 void PrivetURLFetcher::DoNotRetryOnTransientError() {
   DCHECK(tries_ == 0);
   do_not_retry_on_transient_error_ = true;
 }
 
-void PrivetURLFetcher::AllowEmptyPrivetToken() {
+void PrivetURLFetcher::SendEmptyPrivetToken() {
   DCHECK(tries_ == 0);
-  allow_empty_privet_token_ = true;
+  send_empty_privet_token_ = true;
 }
 
 std::string PrivetURLFetcher::GetPrivetAccessToken() {
+  if (send_empty_privet_token_) {
+    return std::string();
+  }
+
   TokenMapHolder* token_map_holder = TokenMapHolder::GetInstance();
   TokenMap::iterator found = token_map_holder->map.find(GetHostString());
   return found != token_map_holder->map.end() ? found->second : std::string();
 }
 
 std::string PrivetURLFetcher::GetHostString() {
   return url_.GetOrigin().spec();
 }
 
 void PrivetURLFetcher::SaveResponseToFile() {
@@ skipping 48 matching lines @@
 
     url_fetcher_->Start();
   } else {
     delegate_->OnError(this, RETRY_ERROR);
   }
 }
 
 void PrivetURLFetcher::Start() {
   DCHECK_EQ(tries_, 0);  // We haven't called |Start()| yet.
 
-  std::string privet_access_token = GetPrivetAccessToken();
-  if (privet_access_token.empty() && !allow_empty_privet_token_) {
-    RequestTokenRefresh();
-  } else {
-    Try();
+  if (!send_empty_privet_token_) {
+    std::string privet_access_token;
+    privet_access_token = GetPrivetAccessToken();
+    if (privet_access_token.empty()) {
+      RequestTokenRefresh();
+      return;
+    }
   }
+
+  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;
   upload_data_ = upload_data;
 }
 
 void PrivetURLFetcher::SetUploadFilePath(
@@ skipping 143 matching lines @@
   }
 }
 
 bool PrivetURLFetcher::PrivetErrorTransient(const std::string& error) {
   return (error == kPrivetErrorDeviceBusy) ||
          (error == kPrivetErrorPendingUserAction) ||
          (error == kPrivetErrorPrinterBusy);
 }
 
 }  // namespace local_discovery