libaddressinput: simplify json interface

merge HasStringValue and GetStringValue

BUG=none

Review URL: https://codereview.chromium.org/113293011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@242253 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 56 insertions, 62 deletions

diff --git a/third_party/libaddressinput/chromium/cpp/src/rule.cc b/third_party/libaddressinput/chromium/cpp/src/rule.cc
index 15d1344..98cfb04 100644
--- a/third_party/libaddressinput/chromium/cpp/src/rule.cc
+++ b/third_party/libaddressinput/chromium/cpp/src/rule.cc
@@ -125,34 +125,34 @@ bool Rule::ParseSerializedRule(const std::string& serialized_rule) {
     return false;
   }
 
-  if (json->HasStringValueForKey(kFormatKey)) {
-    ParseAddressFieldsFormat(json->GetStringValueForKey(kFormatKey), &format_);
+  std::string format;
+  if (json->GetStringValueForKey(kFormatKey, &format)) {
+    ParseAddressFieldsFormat(format, &format_);
   }
 
-  if (json->HasStringValueForKey(kSubKeysKey)) {
-    SplitString(
-        json->GetStringValueForKey(kSubKeysKey), kSeparator, &sub_keys_);
+  std::string subkeys;
+  if (json->GetStringValueForKey(kSubKeysKey, &subkeys)) {
+    SplitString(subkeys, kSeparator, &sub_keys_);
   }
 
-  if (json->HasStringValueForKey(kLanguagesKey)) {
-    SplitString(
-        json->GetStringValueForKey(kLanguagesKey), kSeparator, &languages_);
+  std::string languages;
+  if (json->GetStringValueForKey(kLanguagesKey, &languages)) {
+    SplitString(languages, kSeparator, &languages_);
   }
 
-  if (json->HasStringValueForKey(kLanguageKey)) {
-    language_ = json->GetStringValueForKey(kLanguageKey);
-  }
+  json->GetStringValueForKey(kLanguageKey, &language_);
 
-  if (json->HasStringValueForKey(kAdminAreaNameTypeKey)) {
+  std::string area_name_type;
+  if (json->GetStringValueForKey(kAdminAreaNameTypeKey, &area_name_type)) {
     admin_area_name_message_id_ =
-        GetMessageIdFromName(json->GetStringValueForKey(kAdminAreaNameTypeKey),
-                             GetAdminAreaMessageIds());
+        GetMessageIdFromName(area_name_type, GetAdminAreaMessageIds());
   }
 
-  if (json->HasStringValueForKey(kPostalCodeNameTypeKey)) {
+  std::string postal_code_name_type;
+  if (json->GetStringValueForKey(kPostalCodeNameTypeKey,
+                                 &postal_code_name_type)) {
     postal_code_name_message_id_ =
-        GetMessageIdFromName(json->GetStringValueForKey(kPostalCodeNameTypeKey),
-                             GetPostalCodeMessageIds());
+        GetMessageIdFromName(postal_code_name_type, GetPostalCodeMessageIds());
   }
 
   return true;
diff --git a/third_party/libaddressinput/chromium/cpp/src/util/json.cc b/third_party/libaddressinput/chromium/cpp/src/util/json.cc
index 871bae2..f244bf6 100644
--- a/third_party/libaddressinput/chromium/cpp/src/util/json.cc
+++ b/third_party/libaddressinput/chromium/cpp/src/util/json.cc
@@ -41,19 +41,19 @@ class Rapidjson : public Json {
     return valid_;
   }
 
-  virtual bool HasStringValueForKey(const std::string& key) const {
+  virtual bool GetStringValueForKey(const std::string& key,
+                                    std::string* value) const {
     assert(valid_);
     const rapidjson::Value::Member* member = document_->FindMember(key.c_str());
-    return member != NULL && member->value.IsString();
-  }
+    if (member == NULL || !member->value.IsString()) {
+      return false;
+    }
 
-  virtual std::string GetStringValueForKey(const std::string& key) const {
-    assert(valid_);
-    const rapidjson::Value::Member* member = document_->FindMember(key.c_str());
-    assert(member != NULL);
-    assert(member->value.IsString());
-    return std::string(member->value.GetString(),
-                       member->value.GetStringLength());
+    if (value) {
+      value->assign(member->value.GetString(), member->value.GetStringLength());
+    }
+
+    return true;
   }
 
  protected:
diff --git a/third_party/libaddressinput/chromium/cpp/src/util/json.h b/third_party/libaddressinput/chromium/cpp/src/util/json.h
index 772dce4..a96b0b3 100644
--- a/third_party/libaddressinput/chromium/cpp/src/util/json.h
+++ b/third_party/libaddressinput/chromium/cpp/src/util/json.h
@@ -39,15 +39,11 @@ class Json {
   // object.
   virtual bool ParseObject(const std::string& json) = 0;
 
-  // Returns true if the parsed JSON contains a string value for |key|. The JSON
-  // object must be parsed successfully in ParseObject() before invoking this
-  // method.
-  virtual bool HasStringValueForKey(const std::string& key) const = 0;
-
-  // Returns the string value for the |key|. The |key| must be present and its
-  // value must be of string type, i.e., HasStringValueForKey(key) must return
-  // true before invoking this method.
-  virtual std::string GetStringValueForKey(const std::string& key) const = 0;
+  // Sets |value| to the string for |key| if it exists, or false if the key
+  // doesn't exist or doesn't correspond to a string. The JSON object must be
+  // parsed successfully in ParseObject() before invoking this method.
+  virtual bool GetStringValueForKey(const std::string& key,
+                                    std::string* value) const = 0;
 
  protected:
   Json();
diff --git a/third_party/libaddressinput/chromium/cpp/test/util/json_test.cc b/third_party/libaddressinput/chromium/cpp/test/util/json_test.cc
index 756149f..3259bfe 100644
--- a/third_party/libaddressinput/chromium/cpp/test/util/json_test.cc
+++ b/third_party/libaddressinput/chromium/cpp/test/util/json_test.cc
@@ -41,8 +41,8 @@ TEST_F(JsonTest, EmptyStringIsNotValid) {
 
 TEST_F(JsonTest, EmptyDictionaryContainsNoKeys) {
   ASSERT_TRUE(json_->ParseObject("{}"));
-  EXPECT_FALSE(json_->HasStringValueForKey("key"));
-  EXPECT_FALSE(json_->HasStringValueForKey(std::string()));
+  EXPECT_FALSE(json_->GetStringValueForKey("key", NULL));
+  EXPECT_FALSE(json_->GetStringValueForKey(std::string(), NULL));
 }
 
 TEST_F(JsonTest, InvalidJsonIsNotValid) {
@@ -51,31 +51,35 @@ TEST_F(JsonTest, InvalidJsonIsNotValid) {
 
 TEST_F(JsonTest, OneKeyIsValid) {
   ASSERT_TRUE(json_->ParseObject("{\"key\": \"value\"}"));
-  ASSERT_TRUE(json_->HasStringValueForKey("key"));
-  EXPECT_EQ("value", json_->GetStringValueForKey("key"));
+  std::string value;
+  ASSERT_TRUE(json_->GetStringValueForKey("key", &value));
+  EXPECT_EQ("value", value);
 }
 
 TEST_F(JsonTest, EmptyStringKeyIsNotInObject) {
   ASSERT_TRUE(json_->ParseObject("{\"key\": \"value\"}"));
-  EXPECT_FALSE(json_->HasStringValueForKey(std::string()));
+  EXPECT_FALSE(json_->GetStringValueForKey(std::string(), NULL));
 }
 
 TEST_F(JsonTest, EmptyKeyIsValid) {
   ASSERT_TRUE(json_->ParseObject("{\"\": \"value\"}"));
-  ASSERT_TRUE(json_->HasStringValueForKey(std::string()));
-  EXPECT_EQ("value", json_->GetStringValueForKey(std::string()));
+  std::string value;
+  EXPECT_TRUE(json_->GetStringValueForKey(std::string(), &value));
+  EXPECT_EQ("value", value);
 }
 
 TEST_F(JsonTest, EmptyValueIsValid) {
   ASSERT_TRUE(json_->ParseObject("{\"key\": \"\"}"));
-  ASSERT_TRUE(json_->HasStringValueForKey("key"));
-  EXPECT_TRUE(json_->GetStringValueForKey("key").empty());
+  std::string value;
+  EXPECT_TRUE(json_->GetStringValueForKey("key", &value));
+  EXPECT_EQ(std::string(), value);
 }
 
 TEST_F(JsonTest, Utf8EncodingIsValid) {
   ASSERT_TRUE(json_->ParseObject("{\"key\": \"Ü\"}"));
-  ASSERT_TRUE(json_->HasStringValueForKey("key"));
-  EXPECT_EQ("Ü", json_->GetStringValueForKey("key"));
+  std::string value;
+  EXPECT_TRUE(json_->GetStringValueForKey("key", &value));
+  EXPECT_EQ("Ü", value);
 }
 
 TEST_F(JsonTest, InvalidUtf8IsNotValid) {
@@ -90,11 +94,12 @@ TEST_F(JsonTest, NullInMiddleIsNotValid) {
 TEST_F(JsonTest, TwoKeysAreValid) {
   ASSERT_TRUE(
       json_->ParseObject("{\"key1\": \"value1\", \"key2\": \"value2\"}"));
-  ASSERT_TRUE(json_->HasStringValueForKey("key1"));
-  EXPECT_EQ("value1", json_->GetStringValueForKey("key1"));
+  std::string value;
+  EXPECT_TRUE(json_->GetStringValueForKey("key1", &value));
+  EXPECT_EQ("value1", value);
 
-  ASSERT_TRUE(json_->HasStringValueForKey("key2"));
-  EXPECT_EQ("value2", json_->GetStringValueForKey("key2"));
+  EXPECT_TRUE(json_->GetStringValueForKey("key2", &value));
+  EXPECT_EQ("value2", value);
 }
 
 TEST_F(JsonTest, ListIsNotValid) {
diff --git a/third_party/libaddressinput/chromium/json.cc b/third_party/libaddressinput/chromium/json.cc
index 6723846..4a0fcd5 100644
--- a/third_party/libaddressinput/chromium/json.cc
+++ b/third_party/libaddressinput/chromium/json.cc
@@ -21,7 +21,7 @@ class ChromeJson : public Json {
 
   virtual ~ChromeJson() {}
 
-  virtual bool ParseObject(const std::string& json) {
+  virtual bool ParseObject(const std::string& json) OVERRIDE {
     dict_.reset();
 
     // |json| is converted to a |c_str()| here because rapidjson and other parts
@@ -33,16 +33,9 @@ class ChromeJson : public Json {
     return !!dict_;
   }
 
-  virtual bool HasStringValueForKey(const std::string& key) const {
-    base::Value* val = NULL;
-    dict_->GetWithoutPathExpansion(key, &val);
-    return val && val->IsType(base::Value::TYPE_STRING);
-  }
-
-  virtual std::string GetStringValueForKey(const std::string& key) const {
-    std::string result;
-    dict_->GetStringWithoutPathExpansion(key, &result);
-    return result;
+  virtual bool GetStringValueForKey(const std::string& key, std::string* value)
+      const OVERRIDE {
+    return dict_->GetStringWithoutPathExpansion(key, value);
   }
 
  private: