Move PageTransition from //content/public/common to //ui/base

chrome/browser/history/history_unittest.cc

 // Copyright (c) 2012 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 1101 matching lines @@
   URLRow query_url_row_;
   VisitVector query_url_visits_;
 };
 
 TEST_F(HistoryTest, AddPage) {
   ASSERT_TRUE(history_service_.get());
   // Add the page once from a child frame.
   const GURL test_url("http://www.google.com/");
   history_service_->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
                             history::RedirectList(),
-                            content::PAGE_TRANSITION_MANUAL_SUBFRAME,
+                            ui::PAGE_TRANSITION_MANUAL_SUBFRAME,
                             history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), 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_service_->AddPage(test_url, base::Time::Now(), NULL, 0, GURL(),
-                   history::RedirectList(), content::PAGE_TRANSITION_LINK,
+                   history::RedirectList(), ui::PAGE_TRANSITION_LINK,
                    history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), 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, AddRedirect) {
   ASSERT_TRUE(history_service_.get());
   const char* first_sequence[] = {
     "http://first.page.com/",
     "http://second.page.com/"};
   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_service_->AddPage(
       first_redirects.back(), base::Time::Now(),
       reinterpret_cast<ContextID>(1), 0, GURL(), first_redirects,
-      content::PAGE_TRANSITION_LINK, history::SOURCE_BROWSED, true);
+      ui::PAGE_TRANSITION_LINK, 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_service_.get(), 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(content::PAGE_TRANSITION_LINK |
-            content::PAGE_TRANSITION_CHAIN_START,
+  EXPECT_EQ(ui::PAGE_TRANSITION_LINK |
+            ui::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_service_.get(), 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(content::PAGE_TRANSITION_SERVER_REDIRECT |
-            content::PAGE_TRANSITION_CHAIN_END,
+  EXPECT_EQ(ui::PAGE_TRANSITION_SERVER_REDIRECT |
+            ui::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_service_.get(), 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.com/"));
   history_service_->AddPage(second_redirects[1], base::Time::Now(),
                    reinterpret_cast<ContextID>(1), 1,
                    second_redirects[0], second_redirects,
-                   static_cast<content::PageTransition>(
-                       content::PAGE_TRANSITION_LINK |
-                       content::PAGE_TRANSITION_CLIENT_REDIRECT),
+                   ui::PageTransitionFromInt(
+                       ui::PAGE_TRANSITION_LINK |
+                       ui::PAGE_TRANSITION_CLIENT_REDIRECT),
                    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_service_.get(), 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_service_.get(), second_redirects[1]));
   EXPECT_EQ(1, query_url_row_.visit_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_CLIENT_REDIRECT |
-            content::PAGE_TRANSITION_CHAIN_END,
+  EXPECT_EQ(ui::PAGE_TRANSITION_CLIENT_REDIRECT |
+            ui::PAGE_TRANSITION_CHAIN_END,
             query_url_visits_[0].transition);
   EXPECT_EQ(second_visit, query_url_visits_[0].referring_visit);
 }
 
 TEST_F(HistoryTest, MakeIntranetURLsTyped) {
   ASSERT_TRUE(history_service_.get());
 
   // Add a non-typed visit to an intranet URL on an unvisited host.  This should
   // get promoted to a typed visit.
   const GURL test_url("http://intranet_host/path");
   history_service_->AddPage(
       test_url, base::Time::Now(), NULL, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_LINK,
+      history::RedirectList(), ui::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_TYPED,
-      content::PageTransitionStripQualifier(query_url_visits_[0].transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_TYPED,
+      ui::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Add more visits on the same host.  None of these should be promoted since
   // there is already a typed visit.
 
   // Different path.
   const GURL test_url2("http://intranet_host/different_path");
   history_service_->AddPage(
       test_url2, base::Time::Now(), NULL, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_LINK,
+      history::RedirectList(), ui::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url2));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_LINK,
-      content::PageTransitionStripQualifier(query_url_visits_[0].transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
+      ui::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // No path.
   const GURL test_url3("http://intranet_host/");
   history_service_->AddPage(
       test_url3, base::Time::Now(), NULL, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_LINK,
+      history::RedirectList(), ui::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url3));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_LINK,
-      content::PageTransitionStripQualifier(query_url_visits_[0].transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
+      ui::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Different scheme.
   const GURL test_url4("https://intranet_host/");
   history_service_->AddPage(
       test_url4, base::Time::Now(), NULL, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_LINK,
+      history::RedirectList(), ui::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url4));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_LINK,
-      content::PageTransitionStripQualifier(query_url_visits_[0].transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
+      ui::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Different transition.
   const GURL test_url5("http://intranet_host/another_path");
   history_service_->AddPage(
       test_url5, base::Time::Now(), NULL, 0, GURL(),
       history::RedirectList(),
-      content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url5));
   EXPECT_EQ(1, query_url_row_.visit_count());
   EXPECT_EQ(0, query_url_row_.typed_count());
   ASSERT_EQ(1U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_AUTO_BOOKMARK,
-      content::PageTransitionStripQualifier(query_url_visits_[0].transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_AUTO_BOOKMARK,
+      ui::PageTransitionStripQualifier(query_url_visits_[0].transition));
 
   // Original URL.
   history_service_->AddPage(
       test_url, base::Time::Now(), NULL, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_LINK,
+      history::RedirectList(), ui::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   EXPECT_EQ(2, query_url_row_.visit_count());
   EXPECT_EQ(1, query_url_row_.typed_count());
   ASSERT_EQ(2U, query_url_visits_.size());
-  EXPECT_EQ(content::PAGE_TRANSITION_LINK,
-      content::PageTransitionStripQualifier(query_url_visits_[1].transition));
+  EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
+      ui::PageTransitionStripQualifier(query_url_visits_[1].transition));
 }
 
 TEST_F(HistoryTest, Typed) {
   const ContextID context_id = reinterpret_cast<ContextID>(1);
 
   ASSERT_TRUE(history_service_.get());
 
   // Add the page once as typed.
   const GURL test_url("http://www.google.com/");
   history_service_->AddPage(
       test_url, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_TYPED,
+      history::RedirectList(), ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), 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_service_->AddPage(
       test_url, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_LINK,
+      history::RedirectList(), ui::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), 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_service_->AddPage(
       test_url, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_GENERATED,
+      history::RedirectList(), ui::PAGE_TRANSITION_GENERATED,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), 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_service_->AddPage(
       test_url, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_RELOAD,
+      history::RedirectList(), ui::PAGE_TRANSITION_RELOAD,
       history::SOURCE_BROWSED, false);
   EXPECT_TRUE(QueryURL(history_service_.get(), 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) {
   ASSERT_TRUE(history_service_.get());
@@ skipping 31 matching lines @@
   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/");
 
   const ContextID context_id = reinterpret_cast<ContextID>(1);
 
   // Add two pages.
   history_service_->AddPage(
       url0, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_TYPED,
+      history::RedirectList(), ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->AddPage(
       url1, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_TYPED,
+      history::RedirectList(), ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20,
       90,
       base::Bind(&HistoryTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
   base::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_service_->AddPage(
       url2, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_TYPED,
+      history::RedirectList(), ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20,
       90,
       base::Bind(&HistoryTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
   base::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_service_->AddPage(
       url2, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_TYPED,
+      history::RedirectList(), ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20,
       90,
       base::Bind(&HistoryTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
   base::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_service_->AddPage(
       url1, base::Time::Now(), context_id, 0, GURL(),
-      history::RedirectList(), content::PAGE_TRANSITION_TYPED,
+      history::RedirectList(), ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20,
       90,
       base::Bind(&HistoryTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
   base::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_service_->AddPage(
       url4, base::Time::Now(), context_id, 0, GURL(),
-      redirects, content::PAGE_TRANSITION_TYPED,
+      redirects, ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20,
       90,
       base::Bind(&HistoryTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(4U, most_visited_urls_.size());
@@ skipping 84 matching lines @@
 // returned for the second time.
 TEST_F(HistoryTest, ProcessLocalDeleteDirectiveSyncOnline) {
   ASSERT_TRUE(history_service_.get());
 
   const GURL test_url("http://www.google.com/");
   for (int64 i = 1; i <= 10; ++i) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
-                              content::PAGE_TRANSITION_LINK,
+                              ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   sync_pb::HistoryDeleteDirectiveSpecifics delete_directive;
   sync_pb::GlobalIdDirective* global_id_directive =
       delete_directive.mutable_global_id_directive();
   global_id_directive->add_global_id(
       (base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1))
       .ToInternalValue());
 
@@ skipping 44 matching lines @@
 // including ones that don't exist. The expected entries should be
 // deleted.
 TEST_F(HistoryTest, ProcessGlobalIdDeleteDirective) {
   ASSERT_TRUE(history_service_.get());
   const GURL test_url("http://www.google.com/");
   for (int64 i = 1; i <= 20; i++) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
-                              content::PAGE_TRANSITION_LINK,
+                              ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   EXPECT_EQ(20, query_url_row_.visit_count());
 
   syncer::SyncDataList directives;
   // 1st directive.
   sync_pb::EntitySpecifics entity_specs;
   sync_pb::GlobalIdDirective* global_id_directive =
@@ skipping 70 matching lines @@
 // Create delete directives for time ranges.  The expected entries should be
 // deleted.
 TEST_F(HistoryTest, ProcessTimeRangeDeleteDirective) {
   ASSERT_TRUE(history_service_.get());
   const GURL test_url("http://www.google.com/");
   for (int64 i = 1; i <= 10; ++i) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
-                              content::PAGE_TRANSITION_LINK,
+                              ui::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   EXPECT_EQ(10, query_url_row_.visit_count());
 
   syncer::SyncDataList directives;
   // 1st directive.
   sync_pb::EntitySpecifics entity_specs;
   sync_pb::TimeRangeDirective* time_range_directive =
@@ skipping 120 matching lines @@
   std::vector<PageUsageData*> results;
   db_->QuerySegmentUsage(segment_time, 10, &results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(url, results[0]->GetURL());
   EXPECT_EQ(segment_id, results[0]->GetID());
   EXPECT_EQ(title, results[0]->GetTitle());
   STLDeleteElements(&results);
 }
 
 }  // namespace history