Make GetBestPageForOnlineURL async

chrome/browser/android/offline_pages/offline_page_tab_helper_unittest.cc

 // Copyright 2016 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/android/offline_pages/offline_page_tab_helper.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/offline_page_utils.h"
 #include "chrome/browser/android/offline_pages/test_offline_page_model_builder.h"
 #include "chrome/browser/net/nqe/ui_network_quality_estimator_service.h"
 #include "chrome/browser/net/nqe/ui_network_quality_estimator_service_factory.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 12 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
 const GURL kTestPageUrl("http://test.org/page1");
 const ClientId kTestClientId = ClientId(kBookmarkNamespace, "1234");
 const int64_t kTestFileSize = 876543LL;
 const char kRedirectResultHistogram[] = "OfflinePages.RedirectResult";
-const char kTabId[] = "42";
+const int kTabId = 42;
 
 class TestNetworkChangeNotifier : public net::NetworkChangeNotifier {
  public:
   TestNetworkChangeNotifier() : online_(true) {}
 
   net::NetworkChangeNotifier::ConnectionType GetCurrentConnectionType()
       const override {
     return online_ ? net::NetworkChangeNotifier::CONNECTION_UNKNOWN
                    : net::NetworkChangeNotifier::CONNECTION_NONE;
   }
 
   void set_online(bool online) { online_ = online; }
 
  private:
   bool online_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkChangeNotifier);
 };
 
 class TestDelegate : public OfflinePageTabHelper::Delegate {
  public:
   TestDelegate(bool has_tab_android,
-               std::string tab_id,
+               int tab_id,
                base::SimpleTestClock* clock)
       : clock_(clock), has_tab_android_(has_tab_android), tab_id_(tab_id) {}
   ~TestDelegate() override {}
 
   // offline_pages::OfflinePageTabHelper::Delegate implementation:
   bool GetTabId(content::WebContents* web_contents,
-                std::string* tab_id) const override {
+                int* tab_id) const override {
     if (has_tab_android_)
       *tab_id = tab_id_;
     return has_tab_android_;
   }
 
   base::Time Now() const override { return clock_->Now(); }
 
  private:
   base::SimpleTestClock* clock_;
   bool has_tab_android_;
-  std::string tab_id_;
+  int tab_id_;
 };
 
 }  // namespace
 
 class OfflinePageTabHelperTest :
     public ChromeRenderViewHostTestHarness,
     public OfflinePageTestArchiver::Observer,
     public base::SupportsWeakPtr<OfflinePageTabHelperTest> {
  public:
   OfflinePageTabHelperTest()
@@ skipping 233 matching lines @@
 // test is related to |kTabId|, as it is saved in the latest moment and can be
 // used in the current tab.
 TEST_F(OfflinePageTabHelperTest, SelectBestPageForCurrentTab) {
   // Saves an offline page.
   OfflinePageModel* model =
       OfflinePageModelFactory::GetForBrowserContext(browser_context());
   std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
       kTestPageUrl, base::FilePath(FILE_PATH_LITERAL("page2.mhtml"))));
 
   // We expect this copy to be used later.
-  ClientId client_id(kLastNNamespace, kTabId);
+  ClientId client_id(kLastNNamespace, base::IntToString(kTabId));
   model->SavePage(
       kTestPageUrl, client_id, std::move(archiver),
       base::Bind(&OfflinePageTabHelperTest::OnSavePageDone, AsWeakPtr()));
   RunUntilIdle();
   const int64_t expected_offline_id = offline_id();
   const GURL expected_offline_url = offline_url();
 
   archiver = BuildArchiver(kTestPageUrl,
                            base::FilePath(FILE_PATH_LITERAL("page3.html")));
   client_id.id = "39";
   model->SavePage(
       kTestPageUrl, client_id, std::move(archiver),
       base::Bind(&OfflinePageTabHelperTest::OnSavePageDone, AsWeakPtr()));
   RunUntilIdle();
 
   SimulateHasNetworkConnectivity(false);
   StartLoad(kTestPageUrl);
   // Gives a chance to run delayed task to do redirection.
   RunUntilIdle();
 
   const OfflinePageItem* item =
       OfflinePageUtils::GetOfflinePageFromWebContents(web_contents());
   EXPECT_EQ(expected_offline_id, item->offline_id);
   EXPECT_EQ(expected_offline_url, item->GetOfflineURL());
   EXPECT_EQ(kLastNNamespace, item->client_id.name_space);
-  EXPECT_EQ(kTabId, item->client_id.id);
+  EXPECT_EQ(base::IntToString(kTabId), item->client_id.id);
 }
 
 TEST_F(OfflinePageTabHelperTest, PageFor2GSlow) {
   SimulateHasNetworkConnectivity(true);
   TestingProfile* test_profile = profile();
   UINetworkQualityEstimatorService* nqe_service =
       UINetworkQualityEstimatorServiceFactory::GetForProfile(test_profile);
   nqe_service->SetEffectiveConnectionTypeForTesting(
       net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
 
@@ skipping 34 matching lines @@
 // and verifies it is redirected to it (as it is more recent).
 TEST_F(OfflinePageTabHelperTest, SwitchToOfflineAsyncLoadedPageOnNoNetwork) {
   // Saves an offline page.
   OfflinePageModel* model =
       OfflinePageModelFactory::GetForBrowserContext(browser_context());
   std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
       kTestPageUrl,
       base::FilePath(FILE_PATH_LITERAL("AsyncLoadedPage.mhtml"))));
 
   // We expect this Async Loading Namespace copy to be used.
-  ClientId client_id(kAsyncNamespace, kTabId);
+  ClientId client_id(kAsyncNamespace, base::IntToString(kTabId));
   model->SavePage(
       kTestPageUrl, client_id, std::move(archiver),
       base::Bind(&OfflinePageTabHelperTest::OnSavePageDone, AsWeakPtr()));
   RunUntilIdle();
   const int64_t expected_offline_id = offline_id();
   const GURL expected_offline_url = offline_url();
 
   SimulateHasNetworkConnectivity(false);
   StartLoad(kTestPageUrl);
   // Gives a chance to run delayed task to do redirection.
   RunUntilIdle();
 
   const OfflinePageItem* item =
       OfflinePageUtils::GetOfflinePageFromWebContents(web_contents());
   EXPECT_EQ(expected_offline_id, item->offline_id);
   EXPECT_EQ(expected_offline_url, item->GetOfflineURL());
   EXPECT_EQ(kAsyncNamespace, item->client_id.name_space);
 }
 
 }  // namespace offline_pages