Remove autocheckout code.

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 34 matching lines @@
 const size_t kOneTimePadLength = 6;
 
 // The maximum number of bits in the one time pad that the server is willing to
 // accept.
 const size_t kMaxBits = 56;
 
 // The minimum number of bits in the one time pad that the server is willing to
 // accept.
 const size_t kMinBits = 40;
 
-std::string AutocheckoutStatusToString(AutocheckoutStatus status) {
-  switch (status) {
-    case MISSING_FIELDMAPPING:
-      return "MISSING_FIELDMAPPING";
-    case MISSING_ADVANCE:
-      return "MISSING_ADVANCE";
-    case MISSING_CLICK_ELEMENT_BEFORE_FORM_FILLING:
-      return "MISSING_CLICK_ELEMENT_BEFORE_FORM_FILLING";
-    case MISSING_CLICK_ELEMENT_AFTER_FORM_FILLING:
-      return "MISSING_CLICK_ELEMENT_AFTER_FORM_FILLING";
-    case CANNOT_PROCEED:
-      return "CANNOT_PROCEED";
-    case SUCCESS:
-      // SUCCESS cannot be sent to the server as it will result in a failure.
-      NOTREACHED();
-      return "ERROR";
-    case AUTOCHECKOUT_STATUS_NUM_STATUS:
-      NOTREACHED();
-  }
-  NOTREACHED();
-  return "NOT_POSSIBLE";
-}
-
 std::string DialogTypeToFeatureString(autofill::DialogType dialog_type) {
   switch (dialog_type) {
     case DIALOG_TYPE_REQUEST_AUTOCOMPLETE:
       return "REQUEST_AUTOCOMPLETE";
     case DIALOG_TYPE_AUTOCHECKOUT:
       return "AUTOCHECKOUT";
   }
   NOTREACHED();
   return "NOT_POSSIBLE";
 }
@@ skipping 174 matching lines @@
 const char kPhoneNumberRequired[] = "phone_number_required";
 const char kReasonKey[] = "reason";
 const char kRiskCapabilitiesKey[] = "supported_risk_challenge";
 const char kRiskParamsKey[] = "risk_params";
 const char kSelectedAddressIdKey[] = "selected_address_id";
 const char kSelectedInstrumentIdKey[] = "selected_instrument_id";
 const char kSessionMaterialKey[] = "session_material";
 const char kShippingAddressIdKey[] = "shipping_address_id";
 const char kShippingAddressKey[] = "shipping_address";
 const char kShippingAddressRequired[] = "shipping_address_required";
-const char kAutocheckoutStepsKey[] = "steps";
 const char kSuccessKey[] = "success";
 const char kUpgradedBillingAddressKey[] = "upgraded_billing_address";
 const char kUpgradedInstrumentIdKey[] = "upgraded_instrument_id";
 const char kUseMinimalAddresses[] = "use_minimal_addresses";
 
 }  // namespace
 
 WalletClient::FullWalletRequest::FullWalletRequest(
     const std::string& instrument_id,
     const std::string& address_id,
@@ skipping 242 matching lines @@
                           delegate_->IsShippingAddressRequired());
   request_dict.SetBoolean(kUseMinimalAddresses, false);
   request_dict.SetBoolean(kPhoneNumberRequired, true);
 
   std::string post_body;
   base::JSONWriter::Write(&request_dict, &post_body);
 
   MakeWalletRequest(GetGetWalletItemsUrl(), post_body, kJsonMimeType);
 }
 
-void WalletClient::SendAutocheckoutStatus(
-    AutocheckoutStatus status,
-    const GURL& source_url,
-    const std::vector<AutocheckoutStatistic>& latency_statistics,
-    const std::string& google_transaction_id) {
-  DVLOG(1) << "Sending Autocheckout Status: " << status
-           << " for: " << source_url;
-  if (HasRequestInProgress()) {
-    pending_requests_.push(base::Bind(&WalletClient::SendAutocheckoutStatus,
-                                      base::Unretained(this),
-                                      status,
-                                      source_url,
-                                      latency_statistics,
-                                      google_transaction_id));
-    return;
-  }
-
-  DCHECK_EQ(NO_PENDING_REQUEST, request_type_);
-  request_type_ = SEND_STATUS;
-
-  base::DictionaryValue request_dict;
-  request_dict.SetString(kApiKeyKey, google_apis::GetAPIKey());
-  bool success = status == SUCCESS;
-  request_dict.SetBoolean(kSuccessKey, success);
-  request_dict.SetString(kMerchantDomainKey,
-                         source_url.GetWithEmptyPath().spec());
-  if (!success)
-    request_dict.SetString(kReasonKey, AutocheckoutStatusToString(status));
-  if (!latency_statistics.empty()) {
-    scoped_ptr<base::ListValue> latency_statistics_json(
-        new base::ListValue());
-    for (size_t i = 0; i < latency_statistics.size(); ++i) {
-      latency_statistics_json->Append(
-          latency_statistics[i].ToDictionary().release());
-    }
-    request_dict.Set(kAutocheckoutStepsKey,
-                     latency_statistics_json.release());
-  }
-  request_dict.SetString(kGoogleTransactionIdKey, google_transaction_id);
-
-  std::string post_body;
-  base::JSONWriter::Write(&request_dict, &post_body);
-
-  MakeWalletRequest(GetSendStatusUrl(), post_body, kJsonMimeType);
-}
-
 bool WalletClient::HasRequestInProgress() const {
   return request_;
 }
 
 void WalletClient::CancelRequests() {
   request_.reset();
   request_type_ = NO_PENDING_REQUEST;
   while (!pending_requests_.empty()) {
     pending_requests_.pop();
   }
@@ skipping 134 matching lines @@
     // Anything else is an error.
     default:
       request_type_ = NO_PENDING_REQUEST;
       HandleWalletError(NETWORK_ERROR);
       return;
   }
 
   RequestType type = request_type_;
   request_type_ = NO_PENDING_REQUEST;
 
-  if (!(type == ACCEPT_LEGAL_DOCUMENTS || type == SEND_STATUS) &&
-      !response_dict) {
+  if (type != ACCEPT_LEGAL_DOCUMENTS && !response_dict) {
     HandleMalformedResponse(scoped_request.get());
     return;
   }
 
   switch (type) {
     case ACCEPT_LEGAL_DOCUMENTS:
       delegate_->OnDidAcceptLegalDocuments();
       break;
 
     case AUTHENTICATE_INSTRUMENT: {
       std::string auth_result;
       if (response_dict->GetString(kAuthResultKey, &auth_result)) {
         std::string trimmed;
         TrimWhitespaceASCII(auth_result,
                             TRIM_ALL,
                             &trimmed);
         delegate_->OnDidAuthenticateInstrument(
             LowerCaseEqualsASCII(trimmed, "success"));
       } else {
         HandleMalformedResponse(scoped_request.get());
       }
       break;
     }
 
-    case SEND_STATUS:
-      break;
-
     case GET_FULL_WALLET: {
       scoped_ptr<FullWallet> full_wallet(
           FullWallet::CreateFullWallet(*response_dict));
       if (full_wallet) {
         full_wallet->set_one_time_pad(one_time_pad_);
         LogRequiredActions(full_wallet->required_actions());
         delegate_->OnDidGetFullWallet(full_wallet.Pass());
       } else {
         HandleMalformedResponse(scoped_request.get());
       }
@@ skipping 119 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 SEND_STATUS:
-      return AutofillMetrics::SEND_STATUS;
     case NO_PENDING_REQUEST:
       NOTREACHED();
       return AutofillMetrics::UNKNOWN_API_CALL;
   }
 
   NOTREACHED();
   return AutofillMetrics::UNKNOWN_API_CALL;
 }
 
 }  // namespace wallet
 }  // namespace autofill