Adjust callers and networking delegates in remoting/ to modified APIs

remoting/host/token_validator_base.cc

 // Copyright 2014 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 "remoting/host/token_validator_base.h"
 
 #include <stddef.h>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 67 matching lines @@
 
 const GURL& TokenValidatorBase::token_url() const {
   return third_party_auth_config_.token_url;
 }
 
 const std::string& TokenValidatorBase::token_scope() const {
   return token_scope_;
 }
 
 // URLFetcherDelegate interface.
-void TokenValidatorBase::OnResponseStarted(net::URLRequest* source) {
+void TokenValidatorBase::OnResponseStarted(net::URLRequest* source,
+                                           int net_error) {

[Sergey Ulanov, 2016/09/06 17:43:23]

nit: maybe call this parameter net_result - it's not always an error.

+  DCHECK_NE(net::ERR_IO_PENDING, net_error);

[Sergey Ulanov, 2016/09/06 17:43:23]

nit: please swap these two parameters to make code more readable: 
 DCHECK_NE(net_error, net::ERR_IO_PENDING);

[maksims (do not use this acc), 2016/09/21 05:17:07]

Well, I've always thought it should have been other way round as long as many
people complained that it should have been DCHECK_NE(net::ERR, net_error);

But as you wish!

[Sergey Ulanov, 2016/09/21 07:13:50]

It matters for EXPECT_EQ/EXPECT_NE from gtest, where the first argument is the
expected value. This is not applicable here.

   DCHECK_EQ(request_.get(), source);
 
-  int bytes_read = 0;
-  request_->Read(buffer_.get(), kBufferSize, &bytes_read);
+  int bytes_read = request_->Read(buffer_.get(), kBufferSize);

[Sergey Ulanov, 2016/09/06 17:43:23]

Should we even try reading the response when net_error != OK?

[maksims (do not use this acc), 2016/09/21 05:17:07]

Done.

   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void TokenValidatorBase::OnReadCompleted(net::URLRequest* source,
                                          int bytes_read) {

[Sergey Ulanov, 2016/09/06 17:43:23]

rename this parameter to result or net_result and then you won't need net_error
below.

[maksims (do not use this acc), 2016/09/21 05:17:07]

Done.

   DCHECK_EQ(request_.get(), source);
 
-  do {
-    if (!request_->status().is_success() || bytes_read <= 0)
-      break;
+  while (bytes_read > 0) {
+    data_.append(buffer_->data(), bytes_read);
+    bytes_read = request_->Read(buffer_.get(), kBufferSize);
+  }
 
-    data_.append(buffer_->data(), bytes_read);
-  } while (request_->Read(buffer_.get(), kBufferSize, &bytes_read));
+  int net_error = bytes_read;
+  if (net_error == net::ERR_IO_PENDING)
+    return;
 
-  const net::URLRequestStatus status = request_->status();
-
-  if (!status.is_io_pending()) {
-    retrying_request_ = false;
-    std::string shared_token = ProcessResponse();
-    request_.reset();
-    on_token_validated_.Run(shared_token);
-  }
+  retrying_request_ = false;
+  std::string shared_token = ProcessResponse(net_error);
+  request_.reset();
+  on_token_validated_.Run(shared_token);
 }
 
 void TokenValidatorBase::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
   if (!retrying_request_ && redirect_info.new_method == "GET" &&
       redirect_info.new_url == third_party_auth_config_.token_validation_url) {
     // A sequence of redirects caused the original POST request to become a GET
     // request for this URL. Cancel the request, and re-submit the POST request.
@@ skipping 58 matching lines @@
     }
     request_->ContinueWithCertificate(nullptr, nullptr);
   }
 }
 
 bool TokenValidatorBase::IsValidScope(const std::string& token_scope) {
   // TODO(rmsousa): Deal with reordering/subsets/supersets/aliases/etc.
   return token_scope == token_scope_;
 }
 
-std::string TokenValidatorBase::ProcessResponse() {
+std::string TokenValidatorBase::ProcessResponse(int net_error) {
   // Verify that we got a successful response.
-  net::URLRequestStatus status = request_->status();
-  if (!status.is_success()) {
-    LOG(ERROR) << "Error validating token, status=" << status.status()
-               << " err=" << status.error();
+  if (net_error != net::OK) {
+    LOG(ERROR) << "Error validating token, err=" << net_error;
     return std::string();
   }
 
   int response = request_->GetResponseCode();
   if (response != 200) {
     LOG(ERROR)
         << "Error " << response << " validating token: '" << data_ << "'";
     return std::string();
   }
 
@@ skipping 13 matching lines @@
     return std::string();
   }
 
   std::string shared_secret;
   // Everything is valid, so return the shared secret to the caller.
   dict->GetStringWithoutPathExpansion("access_token", &shared_secret);
   return shared_secret;
 }
 
 }  // namespace remoting