Move two generic string split functions from sync API to their own API in base/string_split.

chrome/browser/sync/engine/net/gaia_authenticator.cc

 // Copyright (c) 2009 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/sync/engine/net/gaia_authenticator.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/port.h"
-#include "base/string_util.h"
+#include "base/string_split.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/net/http_return.h"
 #include "chrome/browser/sync/engine/net/url_translator.h"
 #include "chrome/browser/sync/util/event_sys-inl.h"
 #include "googleurl/src/gurl.h"
 
 using std::pair;
 using std::string;
 using std::vector;
 
-// TODO(timsteele): Integrate the following two functions to string_util.h or
-// somewhere that makes them unit-testable.
-bool SplitStringIntoKeyValues(const string& line,
-                              char key_value_delimiter,
-                              string* key, vector<string>* values) {
-  key->clear();
-  values->clear();
-
-  // find the key string
-  size_t end_key_pos = line.find_first_of(key_value_delimiter);
-  if (end_key_pos == string::npos) {
-    DLOG(INFO) << "cannot parse key from line: " << line;
-    return false;    // no key
-  }
-  key->assign(line, 0, end_key_pos);
-
-  // find the values string
-  string remains(line, end_key_pos, line.size() - end_key_pos);
-  size_t begin_values_pos = remains.find_first_not_of(key_value_delimiter);
-  if (begin_values_pos == string::npos) {
-    DLOG(INFO) << "cannot parse value from line: " << line;
-    return false;   // no value
-  }
-  string values_string(remains, begin_values_pos,
-                       remains.size() - begin_values_pos);
-
-  // construct the values vector
-  values->push_back(values_string);
-  return true;
-}
-
-bool SplitStringIntoKeyValuePairs(const string& line,
-                                  char key_value_delimiter,
-                                  char key_value_pair_delimiter,
-                                  vector<pair<string, string> >* kv_pairs) {
-  kv_pairs->clear();
-
-  vector<string> pairs;
-  SplitString(line, key_value_pair_delimiter, &pairs);
-
-  bool success = true;
-  for (size_t i = 0; i < pairs.size(); ++i) {
-    string key;
-    vector<string> value;
-    if (!SplitStringIntoKeyValues(pairs[i],
-                                  key_value_delimiter,
-                                  &key, &value)) {
-      // Don't return here, to allow for keys without associated
-      // values; just record that our split failed.
-      success = false;
-    }
-    DCHECK_LE(value.size(), 1U);
-    kv_pairs->push_back(make_pair(key, value.empty()? "" : value[0]));
-  }
-  return success;
-}
-
 namespace browser_sync {
 
 static const char kGaiaV1IssueAuthTokenPath[] = "/accounts/IssueAuthToken";
 
 static const char kGetUserInfoPath[] = "/accounts/GetUserInfo";
 
 // Sole constructor with initializers for all fields.
 GaiaAuthenticator::GaiaAuthenticator(const string& user_agent,
                                      const string& service_id,
                                      const string& gaia_url)
@@ skipping 190 matching lines @@
   }
 
   // Check if we received a valid AuthToken; if not, ignore it.
   if (RC_FORBIDDEN == server_response_code) {
     // Server says we're not authenticated.
     ExtractAuthErrorFrom(message_text, results);
     return false;
   } else if (RC_REQUEST_OK == server_response_code) {
     typedef vector<pair<string, string> > Tokens;
     Tokens tokens;
-    SplitStringIntoKeyValuePairs(message_text, '=', '\n', &tokens);
+    base::SplitStringIntoKeyValuePairs(message_text, '=', '\n', &tokens);
     for (Tokens::iterator i = tokens.begin(); i != tokens.end(); ++i) {
       if ("accountType" == i->first) {
         // We never authenticate an email as a hosted account.
         DCHECK_EQ("GOOGLE", i->second);
         results->signin = GMAIL_SIGNIN;
       } else if ("email" == i->first) {
         results->primary_email = i->second;
       }
     }
     return true;
@@ skipping 47 matching lines @@
     return true;
   }
   return false;
 }
 
 // Helper method that extracts tokens from a successful reply, and saves them
 // in the right fields.
 void GaiaAuthenticator::ExtractTokensFrom(const string& response,
                                           AuthResults* results) {
   vector<pair<string, string> > tokens;
-  SplitStringIntoKeyValuePairs(response, '=', '\n', &tokens);
+  base::SplitStringIntoKeyValuePairs(response, '=', '\n', &tokens);
   for (vector<pair<string, string> >::iterator i = tokens.begin();
       i != tokens.end(); ++i) {
     if (i->first == "SID") {
       results->sid = i->second;
     } else if (i->first == "LSID") {
       results->lsid = i->second;
     } else if (i->first == "Auth") {
       results->auth_token = i->second;
     }
   }
 }
 
 // Helper method that extracts tokens from a failure response, and saves them
 // in the right fields.
 void GaiaAuthenticator::ExtractAuthErrorFrom(const string& response,
                                              AuthResults* results) {
   vector<pair<string, string> > tokens;
-  SplitStringIntoKeyValuePairs(response, '=', '\n', &tokens);
+  base::SplitStringIntoKeyValuePairs(response, '=', '\n', &tokens);
   for (vector<pair<string, string> >::iterator i = tokens.begin();
       i != tokens.end(); ++i) {
     if (i->first == "Error") {
       results->error_msg = i->second;
     } else if (i->first == "Url") {
       results->auth_error_url = i->second;
     } else if (i->first == "CaptchaToken") {
       results->captcha_token = i->second;
     } else if (i->first == "CaptchaUrl") {
       results->captcha_url = i->second;
@@ skipping 54 matching lines @@
                                      const string& password,
                                      SaveCredentials should_save_credentials,
                                      SignIn try_first) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   const string empty;
   return Authenticate(user_name, password, should_save_credentials, empty,
                       empty, try_first);
 }
 
 }  // namespace browser_sync