Use upstream libaddressinput in Chrome.

third_party/libaddressinput/chromium/chrome_storage_impl.cc

 // Copyright 2014 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 "third_party/libaddressinput/chromium/chrome_storage_impl.h"
 
+#include "base/memory/scoped_ptr.h"
 #include "base/prefs/writeable_pref_store.h"
 #include "base/values.h"
+#include "third_party/libaddressinput/chromium/fallback_data_store.h"
 
 namespace autofill {
 
 ChromeStorageImpl::ChromeStorageImpl(WriteablePrefStore* store)
     : backing_store_(store),
       scoped_observer_(this) {
   scoped_observer_.Add(backing_store_);
 }
 
 ChromeStorageImpl::~ChromeStorageImpl() {}
 
-void ChromeStorageImpl::Put(const std::string& key,
-                            scoped_ptr<std::string> data) {
-  scoped_ptr<base::StringValue> string_value(
-      new base::StringValue(std::string()));
-  string_value->GetString()->swap(*data);

[Evan Stade, 2014/06/13 20:07:09]

not a copy...

[please use gerrit instead, 2014/06/16 19:02:24]

Now I see. Thank you for pointing it out.

+void ChromeStorageImpl::Put(const std::string& key, const std::string& data) {
+  scoped_ptr<base::StringValue> string_value(new base::StringValue(data));

[Evan Stade, 2014/06/13 20:07:09]

...to copy

[please use gerrit instead, 2014/06/16 19:02:24]

i18n team is changing this to scoped_ptr.

   backing_store_->SetValue(key, string_value.release());
 }
 
-void ChromeStorageImpl::Get(
-    const std::string& key,
-    scoped_ptr<Storage::Callback> data_ready) const {
+void ChromeStorageImpl::Get(const std::string& key,
+                            const Storage::Callback& data_ready) const {
   // |Get()| should not be const, so this is just a thunk that fixes that.
-  const_cast<ChromeStorageImpl*>(this)->DoGet(key, data_ready.Pass());
+  const_cast<ChromeStorageImpl*>(this)->DoGet(key, data_ready);
 }
 
 void ChromeStorageImpl::OnPrefValueChanged(const std::string& key) {}
 
 void ChromeStorageImpl::OnInitializationCompleted(bool succeeded) {
-  for (std::vector<Request*>::iterator iter =
-           outstanding_requests_.begin();
+  for (std::vector<Request*>::iterator iter = outstanding_requests_.begin();
        iter != outstanding_requests_.end(); ++iter) {
-    DoGet((*iter)->key, (*iter)->callback.Pass());
+    DoGet((*iter)->key, (*iter)->callback);
   }
 
   outstanding_requests_.clear();
 }
 
-void ChromeStorageImpl::DoGet(
-    const std::string& key,
-    scoped_ptr<Storage::Callback> data_ready) {
+void ChromeStorageImpl::DoGet(const std::string& key,
+                              const Storage::Callback& data_ready) {
   if (!backing_store_->IsInitializationComplete()) {
-    outstanding_requests_.push_back(
-        new Request(key, data_ready.Pass()));
+    outstanding_requests_.push_back(new Request(key, data_ready));
     return;
   }
 
   const base::Value* value = NULL;
   const base::StringValue* string_value = NULL;
+  std::string fallback_data;
   if (backing_store_->GetValue(key, &value) &&
       value->GetAsString(&string_value)) {
-    (*data_ready)(true, key, string_value->GetString());
+    data_ready(true, key, string_value->GetString());
+  } else if (FallbackDataStore::Get(key, &fallback_data)) {
+    data_ready(true, key, fallback_data);
   } else {
-    (*data_ready)(false, key, std::string());
+    data_ready(false, key, std::string());
   }
 }
 
 ChromeStorageImpl::Request::Request(const std::string& key,
-                                    scoped_ptr<Storage::Callback> callback)
+                                    const Callback& callback)
     : key(key),
-      callback(callback.Pass()) {}
+      callback(callback) {}
 
 }  // namespace autofill