Moved typedef of RedirectList from HistoryService class to history namespace....

chrome/browser/history/history_unittest.cc

 // Copyright (c) 2006-2008 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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
@@ skipping 223 matching lines @@
     history->QueryRedirectsFrom(url, &consumer_,
         NewCallback(this, &HistoryTest::OnRedirectQueryComplete));
     MessageLoop::current()->Run();  // Will be exited in *QueryComplete.
     return redirect_query_success_;
   }
 
   // Callback for QueryRedirects.
   void OnRedirectQueryComplete(HistoryService::Handle handle,
                                GURL url,
                                bool success,
-                               HistoryService::RedirectList* redirects) {
+                               history::RedirectList* redirects) {
     redirect_query_success_ = success;
     if (redirect_query_success_)
       saved_redirects_.swap(*redirects);
     else
       saved_redirects_.clear();
     MessageLoop::current()->Quit();
   }
 
   MessageLoopForUI message_loop_;
 
   // PageUsageData vector to test segments.
   ScopedVector<PageUsageData> page_usage_data_;
 
   // When non-NULL, this will be deleted on tear down and we will block until
   // the backend thread has completed. This allows tests for the history
   // service to use this feature, but other tests to ignore this.
   scoped_refptr<HistoryService> history_service_;
 
   // names of the database files
   FilePath history_dir_;
 
   // Set by the thumbnail callback when we get data, you should be sure to
   // clear this before issuing a thumbnail request.
   bool got_thumbnail_callback_;
   std::vector<unsigned char> thumbnail_data_;
 
   // Set by the redirect callback when we get data. You should be sure to
   // clear this before issuing a redirect request.
-  HistoryService::RedirectList saved_redirects_;
+  history::RedirectList saved_redirects_;
   bool redirect_query_success_;
 
   // For history requests.
   CancelableRequestConsumer consumer_;
 
   // For saving URL info after a call to QueryURL
   bool query_url_success_;
   URLRow query_url_row_;
   VisitVector query_url_visits_;
 
@@ skipping 93 matching lines @@
 
 TEST_F(HistoryTest, AddPage) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   // Add the page once from a child frame.
   const GURL test_url("http://www.google.com/");
   history->AddPage(test_url, NULL, 0, GURL(),
                    PageTransition::MANUAL_SUBFRAME,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_url));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   EXPECT_TRUE(query_url_row_.hidden());  // Hidden because of child frame.
 
   // Add the page once from the main frame (should unhide it).
   history->AddPage(test_url, NULL, 0, GURL(), PageTransition::LINK,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_url));
   EXPECT_EQ(2, query_url_row_.visit_count());  // Added twice.
   EXPECT_EQ(0, query_url_row_.typed_count());  // Never typed.
   EXPECT_FALSE(query_url_row_.hidden());  // Because loaded in main frame.
 }
 
 TEST_F(HistoryTest, AddPageSameTimes) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   Time now = Time::Now();
   const GURL test_urls[] = {
     GURL("http://timer.first.page/"),
     GURL("http://timer.second.page/"),
     GURL("http://timer.third.page/"),
   };
 
   // Make sure that two pages added at the same time with no intervening
   // additions have different timestamps.
   history->AddPage(test_urls[0], now, NULL, 0, GURL(),
                    PageTransition::LINK,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_urls[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_TRUE(now == query_url_row_.last_visit());  // gtest doesn't like Time
 
   history->AddPage(test_urls[1], now, NULL, 0, GURL(),
                    PageTransition::LINK,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_urls[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_TRUE(now + TimeDelta::FromMicroseconds(1) ==
       query_url_row_.last_visit());
 
   // Make sure the next page, at a different time, is also correct.
   history->AddPage(test_urls[2], now + TimeDelta::FromMinutes(1),
                    NULL, 0, GURL(),
                    PageTransition::LINK,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_urls[2]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_TRUE(now + TimeDelta::FromMinutes(1) ==
       query_url_row_.last_visit());
 }
 
 TEST_F(HistoryTest, AddRedirect) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   const char* first_sequence[] = {
     "http://first.page/",
     "http://second.page/"};
   int first_count = arraysize(first_sequence);
-  HistoryService::RedirectList first_redirects;
+  history::RedirectList first_redirects;
   for (int i = 0; i < first_count; i++)
     first_redirects.push_back(GURL(first_sequence[i]));
 
   // Add the sequence of pages as a server with no referrer. Note that we need
   // to have a non-NULL page ID scope.
   history->AddPage(first_redirects.back(), MakeFakeHost(1), 0, GURL(),
                    PageTransition::LINK, first_redirects, true);
 
   // The first page should be added once with a link visit type (because we set
   // LINK when we added the original URL, and a referrer of nowhere (0).
@@ skipping 17 matching lines @@
 
   // Check that the redirect finding function successfully reports it.
   saved_redirects_.clear();
   QueryRedirectsFrom(history, first_redirects[0]);
   ASSERT_EQ(1U, saved_redirects_.size());
   EXPECT_EQ(first_redirects[1], saved_redirects_[0]);
 
   // Now add a client redirect from that second visit to a third, client
   // redirects are tracked by the RenderView prior to updating history,
   // so we pass in a CLIENT_REDIRECT qualifier to mock that behavior.
-  HistoryService::RedirectList second_redirects;
+  history::RedirectList second_redirects;
   second_redirects.push_back(first_redirects[1]);
   second_redirects.push_back(GURL("http://last.page/"));
   history->AddPage(second_redirects[1], MakeFakeHost(1), 1,
                    second_redirects[0],
                    static_cast<PageTransition::Type>(PageTransition::LINK |
                        PageTransition::CLIENT_REDIRECT),
                    second_redirects, true);
 
   // The last page (source of the client redirect) should NOT have an
   // additional visit added, because it was a client redirect (normally it
@@ skipping 11 matching lines @@
 }
 
 TEST_F(HistoryTest, Typed) {
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   // Add the page once as typed.
   const GURL test_url("http://www.google.com/");
   history->AddPage(test_url, NULL, 0, GURL(), PageTransition::TYPED,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // We should have the same typed & visit count.
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 
   // Add the page again not typed.
   history->AddPage(test_url, NULL, 0, GURL(), PageTransition::LINK,
-                   HistoryService::RedirectList(), false);
+                   history::RedirectList(), false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // The second time should not have updated the typed count.
   EXPECT_EQ(2, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 
   // Add the page again as a generated URL.
   history->AddPage(test_url, NULL, 0, GURL(),
-                   PageTransition::GENERATED, HistoryService::RedirectList(),
+                   PageTransition::GENERATED, history::RedirectList(),
                    false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // This should have worked like a link click.
   EXPECT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 
   // Add the page again as a reload.
   history->AddPage(test_url, NULL, 0, GURL(),
-                   PageTransition::RELOAD, HistoryService::RedirectList(),
+                   PageTransition::RELOAD, history::RedirectList(),
                    false);
   EXPECT_TRUE(QueryURL(history, test_url));
 
   // This should not have incremented any visit counts.
   EXPECT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
 }
 
 TEST_F(HistoryTest, SetTitle) {
   scoped_refptr<HistoryService> history(new HistoryService);
@@ skipping 29 matching lines @@
   scoped_refptr<HistoryService> history(new HistoryService);
   history_service_ = history;
 
   ASSERT_TRUE(history->Init(history_dir_, NULL));
 
   static const void* scope = static_cast<void*>(this);
 
   // Add a URL.
   const GURL existing_url("http://www.google.com/");
   history->AddPage(existing_url, scope, 0, GURL(),
-                   PageTransition::TYPED, HistoryService::RedirectList(),
+                   PageTransition::TYPED, history::RedirectList(),
                    false);
 
   // Make sure a segment was created.
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       NewCallback(static_cast<HistoryTest*>(this),
                   &HistoryTest::OnSegmentUsageAvailable));
 
   // Wait for processing.
   MessageLoop::current()->Run();
 
   ASSERT_EQ(1U, page_usage_data_->size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
   EXPECT_DOUBLE_EQ(3.0, page_usage_data_[0]->GetScore());
 
   // Add a URL which doesn't create a segment.
   const GURL link_url("http://yahoo.com/");
   history->AddPage(link_url, scope, 0, GURL(),
-                   PageTransition::LINK, HistoryService::RedirectList(),
+                   PageTransition::LINK, history::RedirectList(),
                    false);
 
   // Query again
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       NewCallback(static_cast<HistoryTest*>(this),
                   &HistoryTest::OnSegmentUsageAvailable));
 
   // Wait for processing.
   MessageLoop::current()->Run();
 
   // Make sure we still have one segment.
   ASSERT_EQ(1U, page_usage_data_->size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
 
   // Add a page linked from existing_url.
   history->AddPage(GURL("http://www.google.com/foo"), scope, 3, existing_url,
-                   PageTransition::LINK, HistoryService::RedirectList(),
+                   PageTransition::LINK, history::RedirectList(),
                    false);
 
   // Query again
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       NewCallback(static_cast<HistoryTest*>(this),
                   &HistoryTest::OnSegmentUsageAvailable));
 
   // Wait for processing.
   MessageLoop::current()->Run();
@@ skipping 108 matching lines @@
 // Creates a new HistoryAddPageArgs object for sending to the history database
 // with reasonable defaults and the given NULL-terminated URL string. The
 // returned object will NOT be add-ref'ed, which is the responsibility of the
 // caller.
 HistoryAddPageArgs* MakeAddArgs(const GURL& url) {
   return new HistoryAddPageArgs(url,
                                 Time::Now(),
                                 kAddArgsScope,
                                 0,
                                 GURL(),
-                                HistoryService::RedirectList(),
+                                history::RedirectList(),
                                 PageTransition::TYPED, false);
 }
 
 // Convenience version of the above to convert a char string.
 HistoryAddPageArgs* MakeAddArgs(const char* url) {
   return MakeAddArgs(GURL(url));
 }
 
 // A HistoryDBTask implementation. Each time RunOnDBThread is invoked
 // invoke_count is increment. When invoked kWantInvokeCount times, true is
@@ skipping 54 matching lines @@
   history_service_ = history;
   history->ScheduleDBTask(task.get(), &request_consumer);
   request_consumer.CancelAllRequests();
   CleanupHistoryService();
   // WARNING: history has now been deleted.
   history = NULL;
   ASSERT_FALSE(task->done_invoked);
 }
 
 }  // namespace history