Move PageTransition into content namespace. While I'm touching all these files, I've also updated...

chrome/browser/history/history_unittest.cc

 // Copyright (c) 2011 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 384 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,
+                   content::PAGE_TRANSITION_MANUAL_SUBFRAME,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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,
+  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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,
+                   content::PAGE_TRANSITION_LINK,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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,
+                   content::PAGE_TRANSITION_LINK,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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,
+                   content::PAGE_TRANSITION_LINK,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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);
   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,
+                   content::PAGE_TRANSITION_LINK, first_redirects,
                    history::SOURCE_BROWSED,  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).
   EXPECT_TRUE(QueryURL(history, first_redirects[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   int64 first_visit = query_url_visits_[0].visit_id;
-  EXPECT_EQ(PageTransition::LINK |
-            PageTransition::CHAIN_START, query_url_visits_[0].transition);
+  EXPECT_EQ(content::PAGE_TRANSITION_LINK |
+            content::PAGE_TRANSITION_CHAIN_START,
+            query_url_visits_[0].transition);
   EXPECT_EQ(0, query_url_visits_[0].referring_visit);  // No referrer.
 
   // The second page should be a server redirect type with a referrer of the
   // first page.
   EXPECT_TRUE(QueryURL(history, first_redirects[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
   int64 second_visit = query_url_visits_[0].visit_id;
-  EXPECT_EQ(PageTransition::SERVER_REDIRECT |
-            PageTransition::CHAIN_END, query_url_visits_[0].transition);
+  EXPECT_EQ(content::PAGE_TRANSITION_SERVER_REDIRECT |
+            content::PAGE_TRANSITION_CHAIN_END,
+            query_url_visits_[0].transition);
   EXPECT_EQ(first_visit, query_url_visits_[0].referring_visit);
 
   // 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.
   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),
+                   static_cast<content::PageTransition>(
+                       content::PAGE_TRANSITION_LINK |
+                       content::PAGE_TRANSITION_CLIENT_REDIRECT),
                    second_redirects, history::SOURCE_BROWSED, true);
 
   // The last page (source of the client redirect) should NOT have an
   // additional visit added, because it was a client redirect (normally it
   // would). We should only have 1 left over from the first sequence.
   EXPECT_TRUE(QueryURL(history, second_redirects[0]));
   EXPECT_EQ(1, query_url_row_.visit_count());
 
   // The final page should be set as a client redirect from the previous visit.
   EXPECT_TRUE(QueryURL(history, second_redirects[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(PageTransition::CLIENT_REDIRECT |
-            PageTransition::CHAIN_END, query_url_visits_[0].transition);
+  EXPECT_EQ(content::PAGE_TRANSITION_CLIENT_REDIRECT |
+            content::PAGE_TRANSITION_CHAIN_END, query_url_visits_[0].transition);
   EXPECT_EQ(second_visit, query_url_visits_[0].referring_visit);
 }
 
 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,
+  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_TYPED,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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,
+  history->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, 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, history::RedirectList(),
+                   content::PAGE_TRANSITION_GENERATED, history::RedirectList(),
                    history::SOURCE_BROWSED, 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, history::RedirectList(),
+                   content::PAGE_TRANSITION_RELOAD, history::RedirectList(),
                    history::SOURCE_BROWSED, 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, history::RedirectList(),
+                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
 
   // Make sure a segment was created.
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // 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, history::RedirectList(),
+                   content::PAGE_TRANSITION_LINK, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
 
   // Query again
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // 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, history::RedirectList(),
+                   content::PAGE_TRANSITION_LINK, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
 
   // Query again
   history->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   MessageLoop::current()->Run();
@@ skipping 14 matching lines @@
   const GURL url0("http://www.google.com/url0/");
   const GURL url1("http://www.google.com/url1/");
   const GURL url2("http://www.google.com/url2/");
   const GURL url3("http://www.google.com/url3/");
   const GURL url4("http://www.google.com/url4/");
 
   static const void* scope = static_cast<void*>(this);
 
   // Add two pages.
   history->AddPage(url0, scope, 0, GURL(),
-                   PageTransition::TYPED, history::RedirectList(),
+                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
   history->AddPage(url1, scope, 0, GURL(),
-                   PageTransition::TYPED, history::RedirectList(),
+                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(2U, most_visited_urls_.size());
   EXPECT_EQ(url0, most_visited_urls_[0].url);
   EXPECT_EQ(url1, most_visited_urls_[1].url);
 
   // Add another page.
   history->AddPage(url2, scope, 0, GURL(),
-                   PageTransition::TYPED, history::RedirectList(),
+                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url0, most_visited_urls_[0].url);
   EXPECT_EQ(url1, most_visited_urls_[1].url);
   EXPECT_EQ(url2, most_visited_urls_[2].url);
 
   // Revisit url2, making it the top URL.
   history->AddPage(url2, scope, 0, GURL(),
-                   PageTransition::TYPED, history::RedirectList(),
+                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url2, most_visited_urls_[0].url);
   EXPECT_EQ(url0, most_visited_urls_[1].url);
   EXPECT_EQ(url1, most_visited_urls_[2].url);
 
   // Revisit url1, making it the top URL.
   history->AddPage(url1, scope, 0, GURL(),
-                   PageTransition::TYPED, history::RedirectList(),
+                   content::PAGE_TRANSITION_TYPED, history::RedirectList(),
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url1, most_visited_urls_[0].url);
   EXPECT_EQ(url2, most_visited_urls_[1].url);
   EXPECT_EQ(url0, most_visited_urls_[2].url);
 
   // Redirects
   history::RedirectList redirects;
   redirects.push_back(url3);
   redirects.push_back(url4);
 
   // Visit url4 using redirects.
   history->AddPage(url4, scope, 0, GURL(),
-                   PageTransition::TYPED, redirects,
+                   content::PAGE_TRANSITION_TYPED, redirects,
                    history::SOURCE_BROWSED, false);
   history->QueryMostVisitedURLs(20, 90, &consumer_,
                                 base::Bind(
                                     &HistoryTest::OnMostVisitedURLsAvailable,
                                     base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_EQ(4U, most_visited_urls_.size());
   EXPECT_EQ(url1, most_visited_urls_[0].url);
   EXPECT_EQ(url2, most_visited_urls_[1].url);
@@ skipping 92 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