Send privet auth token in PrivetV3 mode instead of X-Privet token

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 16 matching lines @@
 struct TokenMapHolder {
  public:
   static TokenMapHolder* GetInstance() {
     return Singleton<TokenMapHolder>::get();
   }
 
   TokenMap map;
 };
 
 const char kXPrivetTokenHeaderPrefix[] = "X-Privet-Token: ";
+const char kXPrivetAuthTokenHeaderPrefix[] = "X-Privet-Auth: ";
 const char kRangeHeaderFormat[] = "Range: bytes=%d-%d";
 const char kXPrivetEmptyToken[] = "\"\"";
+const char kPrivetAuthTokenUnknown[] = "Unknown";
 const int kPrivetMaxRetries = 20;
 const int kPrivetTimeoutOnError = 5;
 const int kHTTPErrorCodeInvalidXPrivetToken = 418;
 
 std::string MakeRangeHeader(int start, int end) {
   DCHECK_GE(start, 0);
   DCHECK_GT(end, 0);
   DCHECK_GT(end, start);
   return base::StringPrintf(kRangeHeaderFormat, start, end);
 }
 
 }  // namespace
 
 void PrivetURLFetcher::Delegate::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const TokenCallback& callback) {
   OnError(fetcher, TOKEN_ERROR);
 }
 
+std::string PrivetURLFetcher::Delegate::GetAuthToken() {
+  return kPrivetAuthTokenUnknown;
+}
+
 bool PrivetURLFetcher::Delegate::OnRawData(PrivetURLFetcher* fetcher,
                                            bool response_is_file,
                                            const std::string& data_string,
                                            const base::FilePath& data_file) {
   return false;
 }
 
 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),
       send_empty_privet_token_(false),
       has_byte_range_(false),
       make_response_file_(false),
+      v3_mode_(false),
       byte_range_start_(0),
       byte_range_end_(0),
       tries_(0),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+}
 
 PrivetURLFetcher::~PrivetURLFetcher() {
 }
 
 // static
 void PrivetURLFetcher::SetTokenForHost(const std::string& host,
                                        const std::string& token) {
   TokenMapHolder::GetInstance()->map[host] = token;
 }
 
@@ skipping 24 matching lines @@
 
 std::string PrivetURLFetcher::GetHostString() {
   return url_.GetOrigin().spec();
 }
 
 void PrivetURLFetcher::SaveResponseToFile() {
   DCHECK(tries_ == 0);
   make_response_file_ = true;
 }
 
+void PrivetURLFetcher::V3Mode() {
+  v3_mode_ = true;
+}
+
 void PrivetURLFetcher::SetByteRange(int start, int end) {
   DCHECK(tries_ == 0);
   byte_range_start_ = start;
   byte_range_end_ = end;
   has_byte_range_ = true;
 }
 
 void PrivetURLFetcher::Try() {
   tries_++;
   if (tries_ < kPrivetMaxRetries) {
-    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);
+
+    if (v3_mode_) {
+      std::string auth_token = delegate_->GetAuthToken();
+
+      url_fetcher_->AddExtraRequestHeader(
+          std::string(kXPrivetAuthTokenHeaderPrefix) + auth_token);
+    } else {
+      std::string token = GetPrivetAccessToken();
+
+      if (token.empty())
+        token = kXPrivetEmptyToken;
+
+      url_fetcher_->AddExtraRequestHeader(
+          std::string(kXPrivetTokenHeaderPrefix) + token);
+    }
+
     if (has_byte_range_) {
       url_fetcher_->AddExtraRequestHeader(
           MakeRangeHeader(byte_range_start_, byte_range_end_));
     }
 
     if (make_response_file_) {
       url_fetcher_->SaveResponseToTemporaryFile(
           content::BrowserThread::GetMessageLoopProxyForThread(
               content::BrowserThread::FILE));
     }
@@ skipping 15 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 (!send_empty_privet_token_) {
+  if (!send_empty_privet_token_ && !v3_mode_) {
     std::string privet_access_token;
     privet_access_token = GetPrivetAccessToken();
     if (privet_access_token.empty()) {
       RequestTokenRefresh();
       return;
     }
   }
 
   Try();
 }
@@ skipping 153 matching lines @@
 }
 
 bool PrivetURLFetcher::PrivetErrorTransient(const std::string& error) {
   return (error == kPrivetErrorDeviceBusy) ||
          (error == kPrivetV3ErrorDeviceBusy) ||
          (error == kPrivetErrorPendingUserAction) ||
          (error == kPrivetErrorPrinterBusy);
 }
 
 }  // namespace local_discovery