Adds wallet::RequiredAction for when we start interacting with Online Wallet.

chrome/browser/autofill/wallet/full_wallet.cc

 // Copyright (c) 2012 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/autofill/wallet/full_wallet.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/autofill/wallet/required_action.h"
 
 namespace {
 
 const size_t kPanSize = 16;
 const size_t kBinSize = 6;
 const size_t kCvnSize = 3;
 
 }  // anonymous namespace
 
 namespace wallet {
 
 FullWallet::FullWallet(int expiration_month,
                        int expiration_year,
                        const std::string& iin,
                        const std::string& encrypted_rest,
                        scoped_ptr<Address> billing_address,
                        scoped_ptr<Address> shipping_address,
-                       const std::vector<std::string>& required_actions)
+                       const std::vector<RequiredAction>& required_actions)
     : expiration_month_(expiration_month),
       expiration_year_(expiration_year),
       iin_(iin),
       encrypted_rest_(encrypted_rest),
       billing_address_(billing_address.Pass()),
       shipping_address_(shipping_address.Pass()),
       required_actions_(required_actions) {
   DCHECK(required_actions_.size() > 0 || billing_address_.get());
 }
 
 FullWallet::~FullWallet() {}
 
 scoped_ptr<FullWallet>
     FullWallet::CreateFullWallet(const DictionaryValue& dictionary) {
   const ListValue* required_actions_list;
-  std::vector<std::string> required_actions;
+  std::vector<RequiredAction> required_actions;
   if (dictionary.GetList("required_action", &required_actions_list)) {
     for (size_t i = 0; i < required_actions_list->GetSize(); ++i) {
-      std::string action;
-      if (required_actions_list->GetString(i, &action))
-        required_actions.push_back(action);
+      std::string action_string;
+      if (required_actions_list->GetString(i, &action_string)) {
+        RequiredAction action(RequiredAction::ParseFromString(action_string));

[Ilya Sherman, 2013/01/05 03:15:06]

Add a DCHECK that the parse succeeded?

[Dan Beam, 2013/01/05 03:17:38]

If the parse didn't succeed (and the type ends up UNKNOWN_TYPE),
action.AppliesToFullWallet() returns false.  Still needed?

[Ilya Sherman, 2013/01/05 03:32:58]

Hmm, I guess DCHECKs make testing suck.  Ok, nevermind.

+        if (action.AppliesToFullWallet())
+          required_actions.push_back(action);
+      }
     }
-    if (required_actions.size() > 0)
+    if (required_actions.size() > 0) {
       return scoped_ptr<FullWallet>(new FullWallet(-1,
                                                    -1,
                                                    "",
                                                    "",
                                                    scoped_ptr<Address>(),
                                                    scoped_ptr<Address>(),
                                                    required_actions));
+    }
   } else {
     DVLOG(1) << "Response from Google wallet missing required actions";
   }
 
   int expiration_month;
   if (!dictionary.GetInteger("expiration_month", &expiration_month)) {
     DLOG(ERROR) << "Response from Google wallet missing expiration month";
     return scoped_ptr<FullWallet>();
   }
 
@@ skipping 131 matching lines @@
     card_info.insert(card_info.begin(), padded_length - card_info.size(), '0');
 
   // Separate out the PAN from the CVN.
   size_t split = kPanSize - kBinSize;
   cvn_ = card_info.substr(split);
   pan_ = iin_ + card_info.substr(0, split);
 }
 
 }  // namespace wallet