[rAc - libaddressinput] Chrome download impl

third_party/libaddressinput/chromium/cpp/test/retriever_test.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,
@@ skipping 23 matching lines @@
 const char kKey[] = "data/CA/AB--fr";
 
 // Empty data that the downloader can return.
 const char kEmptyData[] = "{}";
 
 // Tests for Retriever object.
 class RetrieverTest : public testing::Test {
  protected:
   RetrieverTest()
       : retriever_(FakeDownloader::kFakeDataUrl,
-                   scoped_ptr<const Downloader>(new FakeDownloader),
+                   scoped_ptr<Downloader>(new FakeDownloader),
                    scoped_ptr<Storage>(new FakeStorage)),
         success_(false),
         key_(),
         data_() {}
 
   virtual ~RetrieverTest() {}
 
   scoped_ptr<Retriever::Callback> BuildCallback() {
     return ::i18n::addressinput::BuildCallback(
         this, &RetrieverTest::OnDataReady);
@@ skipping 44 matching lines @@
 }
 
 // The downloader that always fails.
 class FaultyDownloader : public Downloader {
  public:
   FaultyDownloader() {}
   virtual ~FaultyDownloader() {}
 
   // Downloader implementation.
   virtual void Download(const std::string& url,
-                        scoped_ptr<Callback> downloaded) const {
+                        scoped_ptr<Callback> downloaded) {
     (*downloaded)(false, url, "garbage");
   }
 };
 
 TEST_F(RetrieverTest, FaultyDownloader) {
   Retriever bad_retriever(FakeDownloader::kFakeDataUrl,
-                          scoped_ptr<const Downloader>(new FaultyDownloader),
+                          scoped_ptr<Downloader>(new FaultyDownloader),
                           scoped_ptr<Storage>(new FakeStorage));
   bad_retriever.Retrieve(kKey, BuildCallback());
 
   EXPECT_FALSE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_TRUE(data_.empty());
 }
 
 // The downloader that doesn't get back to you.
 class HangingDownloader : public Downloader {
  public:
   HangingDownloader() {}
   virtual ~HangingDownloader() {}
 
   // Downloader implementation.
   virtual void Download(const std::string& url,
-                        scoped_ptr<Callback> downloaded) const {}
+                        scoped_ptr<Callback> downloaded) {}
 };
 
 TEST_F(RetrieverTest, RequestsDontStack) {
   Retriever slow_retriever(FakeDownloader::kFakeDataUrl,
-                           scoped_ptr<const Downloader>(new HangingDownloader),
+                           scoped_ptr<Downloader>(new HangingDownloader),
                            scoped_ptr<Storage>(new FakeStorage));
 
   slow_retriever.Retrieve(kKey, BuildCallback());
   EXPECT_FALSE(success_);
   EXPECT_TRUE(key_.empty());
 
 #if !defined(NDEBUG)
   // This request should cause an assert.
   ASSERT_DEATH(slow_retriever.Retrieve(kKey, BuildCallback()), "");
 #endif
 }
 
 }  // namespace
 
 }  // namespace addressinput
 }  // namespace i18n