WalletClient: don't bother queuing requests; we don't make multiple requests concurrently anyway

components/autofill/content/browser/wallet/wallet_client.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 "components/autofill/content/browser/wallet/wallet_client.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 240 matching lines @@
 
 WalletClient::FullWalletRequest::~FullWalletRequest() {}
 
 WalletClient::WalletClient(net::URLRequestContextGetter* context_getter,
                            WalletClientDelegate* delegate,
                            const GURL& source_url)
     : context_getter_(context_getter),
       delegate_(delegate),
       user_index_(0U),
       source_url_(source_url),
-      request_type_(NO_PENDING_REQUEST),
+      request_type_(NO_REQUEST),
       one_time_pad_(kOneTimePadLength),
       weak_ptr_factory_(this) {
   DCHECK(context_getter_.get());
   DCHECK(delegate_);
 }
 
 WalletClient::~WalletClient() {}
 
 void WalletClient::AcceptLegalDocuments(
     const std::vector<WalletItems::LegalDocument*>& documents,
@@ skipping 197 matching lines @@
   MakeWalletRequest(GetGetWalletItemsUrl(user_index_),
                     post_body,
                     kJsonMimeType,
                     GET_WALLET_ITEMS);
 }
 
 bool WalletClient::HasRequestInProgress() const {
   return request_;
 }
 
-void WalletClient::CancelRequests() {
+void WalletClient::CancelRequest() {
   request_.reset();
-  request_type_ = NO_PENDING_REQUEST;
-  while (!pending_requests_.empty()) {
-    pending_requests_.pop();
-  }
+  request_type_ = NO_REQUEST;
 }
 
 void WalletClient::SetUserIndex(size_t user_index) {
-  CancelRequests();
+  CancelRequest();
   user_index_ = user_index;
 }
 
 void WalletClient::DoAcceptLegalDocuments(
     const std::vector<std::string>& document_ids,
     const std::string& google_transaction_id) {
   base::DictionaryValue request_dict;
   request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
   request_dict.SetString(kGoogleTransactionIdKey, google_transaction_id);
   request_dict.SetString(kMerchantDomainKey,
@@ skipping 12 matching lines @@
   MakeWalletRequest(GetAcceptLegalDocumentsUrl(user_index_),
                     post_body,
                     kJsonMimeType,
                     ACCEPT_LEGAL_DOCUMENTS);
 }
 
 void WalletClient::MakeWalletRequest(const GURL& url,
                                      const std::string& post_body,
                                      const std::string& mime_type,
                                      RequestType request_type) {
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::MakeWalletRequest,
-                                      base::Unretained(this),
-                                      url,
-                                      post_body,
-                                      mime_type,
-                                      request_type));
-    return;
-  }
-
-  DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
+  DCHECK_EQ(request_type_, NO_REQUEST);
   request_type_ = request_type;
 
   request_.reset(net::URLFetcher::Create(
       0, url, net::URLFetcher::POST, this));
   request_->SetRequestContext(context_getter_.get());
   DVLOG(1) << "Making request to " << url << " with post_body=" << post_body;
   request_->SetUploadData(mime_type, post_body);
   request_->AddExtraRequestHeader("Authorization: GoogleLogin auth=" +
                                   delegate_->GetWalletCookieValue());
   DVLOG(1) << "Setting authorization header value to "
@@ skipping 14 matching lines @@
       RequestTypeToUmaMetric(request_type_),
       base::Time::Now() - request_started_timestamp_);
 
   DCHECK_EQ(source, request_.get());
   DVLOG(1) << "Got response from " << source->GetOriginalURL();
 
   // |request_|, which is aliased to |source|, might continue to be used in this
   // |method, but should be freed once control leaves the method.
   scoped_ptr<net::URLFetcher> scoped_request(request_.Pass());
 
-  // Prepare to start the next pending request.  This is queued up as an
-  // asynchronous message because |this| WalletClient instance can be destroyed
-  // before the end of the method in response to the current incoming request.
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&WalletClient::StartNextPendingRequest,
-                 weak_ptr_factory_.GetWeakPtr()));;
-
   std::string data;
   source->GetResponseAsString(&data);
   DVLOG(1) << "Response body: " << data;
 
   scoped_ptr<base::DictionaryValue> response_dict;
 
   int response_code = source->GetResponseCode();
   delegate_->GetMetricLogger().LogWalletResponseCode(response_code);
 
   switch (response_code) {
     // HTTP_BAD_REQUEST means the arguments are invalid. No point retrying.
     case net::HTTP_BAD_REQUEST: {
-      request_type_ = NO_PENDING_REQUEST;
+      request_type_ = NO_REQUEST;
       HandleWalletError(BAD_REQUEST);
       return;
     }
     // HTTP_OK holds a valid response and HTTP_INTERNAL_SERVER_ERROR holds an
     // error code and message for the user.
     case net::HTTP_OK:
     case net::HTTP_INTERNAL_SERVER_ERROR: {
       scoped_ptr<base::Value> message_value(base::JSONReader::Read(data));
       if (message_value.get() &&
           message_value->IsType(base::Value::TYPE_DICTIONARY)) {
         response_dict.reset(
             static_cast<base::DictionaryValue*>(message_value.release()));
       }
       if (response_code == net::HTTP_INTERNAL_SERVER_ERROR) {
-        request_type_ = NO_PENDING_REQUEST;
+        request_type_ = NO_REQUEST;
 
         std::string error_type_string;
         if (!response_dict->GetString(kErrorTypeKey, &error_type_string)) {
           HandleWalletError(UNKNOWN_ERROR);
           return;
         }
         WalletClient::ErrorType error_type =
             StringToErrorType(error_type_string);
         if (error_type == BUYER_ACCOUNT_ERROR) {
           // If the error_type is |BUYER_ACCOUNT_ERROR|, then
           // message_type_for_buyer field contains more specific information
           // about the error.
           std::string message_type_for_buyer_string;
           if (response_dict->GetString(kMessageTypeForBuyerKey,
                                        &message_type_for_buyer_string)) {
             error_type = BuyerErrorStringToErrorType(
                 message_type_for_buyer_string);
           }
         }
 
         HandleWalletError(error_type);
         return;
       }
       break;
     }
 
     // Anything else is an error.
     default:
-      request_type_ = NO_PENDING_REQUEST;
+      request_type_ = NO_REQUEST;
       HandleWalletError(NETWORK_ERROR);
       return;
   }
 
   RequestType type = request_type_;
-  request_type_ = NO_PENDING_REQUEST;
+  request_type_ = NO_REQUEST;
 
   if (type != ACCEPT_LEGAL_DOCUMENTS && !response_dict) {
     HandleMalformedResponse(type, scoped_request.get());
     return;
   }
 
   switch (type) {
     case ACCEPT_LEGAL_DOCUMENTS:
       delegate_->OnDidAcceptLegalDocuments();
       break;
@@ skipping 54 matching lines @@
       } else {
         LogRequiredActions(required_actions);
         delegate_->OnDidSaveToWallet(instrument_id,
                                      shipping_address_id,
                                      required_actions,
                                      form_errors);
       }
       break;
     }
 
-    case NO_PENDING_REQUEST:
+    case NO_REQUEST:
       NOTREACHED();
   }
 }
 
-void WalletClient::StartNextPendingRequest() {
-  if (pending_requests_.empty())
-    return;
-
-  base::Closure next_request = pending_requests_.front();
-  pending_requests_.pop();
-  next_request.Run();
-}
-
 void WalletClient::HandleMalformedResponse(RequestType request_type,
                                            net::URLFetcher* request) {
   // Called to inform exponential backoff logic of the error.
   request->ReceivedContentWasMalformed();
   // Record failed API call in metrics.
   delegate_->GetMetricLogger().LogWalletMalformedResponseMetric(
     RequestTypeToUmaMetric(request_type));
   HandleWalletError(MALFORMED_RESPONSE);
 }
 
@@ skipping 60 matching lines @@
     case ACCEPT_LEGAL_DOCUMENTS:
       return AutofillMetrics::ACCEPT_LEGAL_DOCUMENTS;
     case AUTHENTICATE_INSTRUMENT:
       return AutofillMetrics::AUTHENTICATE_INSTRUMENT;
     case GET_FULL_WALLET:
       return AutofillMetrics::GET_FULL_WALLET;
     case GET_WALLET_ITEMS:
       return AutofillMetrics::GET_WALLET_ITEMS;
     case SAVE_TO_WALLET:
       return AutofillMetrics::SAVE_TO_WALLET;
-    case NO_PENDING_REQUEST:
+    case NO_REQUEST:
       NOTREACHED();
       return AutofillMetrics::UNKNOWN_API_CALL;
   }
 
   NOTREACHED();
   return AutofillMetrics::UNKNOWN_API_CALL;
 }
 
 }  // namespace wallet
 }  // namespace autofill