Use upstream libaddressinput in Chrome.

third_party/libaddressinput/chromium/storage_test_runner.cc

-// Copyright (C) 2013 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// 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 "storage_test_runner.h"
+#include "third_party/libaddressinput/chromium/storage_test_runner.h"
 
-#include <libaddressinput/callback.h>
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/libaddressinput/src/cpp/include/libaddressinput/callback.h"
 
-#include <gtest/gtest.h>
+namespace autofill {
 
-namespace i18n {
-namespace addressinput {
+using ::i18n::addressinput::Storage;
 
 StorageTestRunner::StorageTestRunner(Storage* storage)
     : storage_(storage),
       success_(false),
       key_(),
       data_() {}
 
+StorageTestRunner::~StorageTestRunner() {}
+
 void StorageTestRunner::RunAllTests() {
   EXPECT_NO_FATAL_FAILURE(GetWithoutPutReturnsEmptyData());
   EXPECT_NO_FATAL_FAILURE(GetReturnsWhatWasPut());
   EXPECT_NO_FATAL_FAILURE(SecondPutOverwritesData());
 }
 
 void StorageTestRunner::ClearValues() {
   success_ = false;
   key_.clear();
   data_.clear();
 }
 
 scoped_ptr<Storage::Callback> StorageTestRunner::BuildCallback() {
-  return ::i18n::addressinput::BuildCallback(
-      this, &StorageTestRunner::OnDataReady);
+  return scoped_ptr<Storage::Callback>(::i18n::addressinput::BuildCallback(
+      this, &StorageTestRunner::OnDataReady));
 }
 
 void StorageTestRunner::OnDataReady(bool success,
                                     const std::string& key,
                                     const std::string& data) {
   success_ = success;
   key_ = key;
   data_ = data;
 }
 
 void StorageTestRunner::GetWithoutPutReturnsEmptyData() {
   ClearValues();
-  storage_->Get("key", BuildCallback());
+  scoped_ptr<Storage::Callback> callback(BuildCallback());
+  storage_->Get("key", *callback);
 
   EXPECT_FALSE(success_);
   EXPECT_EQ("key", key_);
   EXPECT_TRUE(data_.empty());
 }
 
 void StorageTestRunner::GetReturnsWhatWasPut() {
   ClearValues();
-  storage_->Put("key", make_scoped_ptr(new std::string("value")));
-  storage_->Get("key", BuildCallback());
+  storage_->Put("key", "value");
+  scoped_ptr<Storage::Callback> callback(BuildCallback());
+  storage_->Get("key", *callback);
 
   EXPECT_TRUE(success_);
   EXPECT_EQ("key", key_);
   EXPECT_EQ("value", data_);
 }
 
 void StorageTestRunner::SecondPutOverwritesData() {
   ClearValues();
-  storage_->Put("key", make_scoped_ptr(new std::string("bad-value")));
-  storage_->Put("key", make_scoped_ptr(new std::string("good-value")));
-  storage_->Get("key", BuildCallback());
+  storage_->Put("key", "bad-value");
+  storage_->Put("key", "good-value");
+  scoped_ptr<Storage::Callback> callback(BuildCallback());
+  storage_->Get("key", *callback);
 
   EXPECT_TRUE(success_);
   EXPECT_EQ("key", key_);
   EXPECT_EQ("good-value", data_);
 }
 
-}  // addressinput
-}  // i18n
+}  // namespace autofill