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

components/sessions/serialized_navigation_entry_unittest.cc

 // Copyright (c) 2013 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 "components/sessions/serialized_navigation_entry.h"
 
 #include <cstddef>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
-#include "content/public/common/page_transition_types.h"
 #include "content/public/common/referrer.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/util/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
+#include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 
 namespace sessions {
 namespace {
 
 const int kIndex = 3;
 const int kUniqueID = 50;
 const content::Referrer kReferrer =
     content::Referrer(GURL("http://www.referrer.com"),
                       blink::WebReferrerPolicyAlways);
 const GURL kVirtualURL("http://www.virtual-url.com");
 const base::string16 kTitle = base::ASCIIToUTF16("title");
 const content::PageState kPageState =
     content::PageState::CreateFromEncodedData("page state");
-const content::PageTransition kTransitionType =
-    static_cast<content::PageTransition>(
-        content::PAGE_TRANSITION_AUTO_SUBFRAME |
-        content::PAGE_TRANSITION_HOME_PAGE |
-        content::PAGE_TRANSITION_CLIENT_REDIRECT);
+const ui::PageTransition kTransitionType =
+    ui::PageTransitionFromInt(
+        ui::PAGE_TRANSITION_AUTO_SUBFRAME |
+        ui::PAGE_TRANSITION_HOME_PAGE |
+        ui::PAGE_TRANSITION_CLIENT_REDIRECT);
 const bool kHasPostData = true;
 const int64 kPostID = 100;
 const GURL kOriginalRequestURL("http://www.original-request.com");
 const bool kIsOverridingUserAgent = true;
 const base::Time kTimestamp = syncer::ProtoTimeToTime(100);
 const base::string16 kSearchTerms = base::ASCIIToUTF16("my search terms");
 const GURL kFaviconURL("http://virtual-url.com/favicon.ico");
 const int kHttpStatusCode = 404;
 const GURL kRedirectURL0("http://go/redirect0");
 const GURL kRedirectURL1("http://go/redirect1");
@@ skipping 52 matching lines @@
 // initialized to their respective default values.
 TEST(SerializedNavigationEntryTest, DefaultInitializer) {
   const SerializedNavigationEntry navigation;
   EXPECT_EQ(-1, navigation.index());
   EXPECT_EQ(0, navigation.unique_id());
   EXPECT_EQ(GURL(), navigation.referrer().url);
   EXPECT_EQ(blink::WebReferrerPolicyDefault, navigation.referrer().policy);
   EXPECT_EQ(GURL(), navigation.virtual_url());
   EXPECT_TRUE(navigation.title().empty());
   EXPECT_FALSE(navigation.page_state().IsValid());
-  EXPECT_EQ(content::PAGE_TRANSITION_TYPED, navigation.transition_type());
+  EXPECT_EQ(ui::PAGE_TRANSITION_TYPED, navigation.transition_type());
   EXPECT_FALSE(navigation.has_post_data());
   EXPECT_EQ(-1, navigation.post_id());
   EXPECT_EQ(GURL(), navigation.original_request_url());
   EXPECT_FALSE(navigation.is_overriding_user_agent());
   EXPECT_TRUE(navigation.timestamp().is_null());
   EXPECT_TRUE(navigation.search_terms().empty());
   EXPECT_FALSE(navigation.favicon_url().is_valid());
   EXPECT_EQ(0, navigation.http_status_code());
   EXPECT_EQ(0U, navigation.redirect_chain().size());
 }
@@ skipping 105 matching lines @@
 
   const scoped_ptr<content::NavigationEntry> new_navigation_entry(
       navigation.ToNavigationEntry(kPageID, NULL));
 
   EXPECT_EQ(kReferrer.url, new_navigation_entry->GetReferrer().url);
   EXPECT_EQ(kReferrer.policy, new_navigation_entry->GetReferrer().policy);
   EXPECT_EQ(kVirtualURL, new_navigation_entry->GetVirtualURL());
   EXPECT_EQ(kTitle, new_navigation_entry->GetTitle());
   EXPECT_EQ(kPageState, new_navigation_entry->GetPageState());
   EXPECT_EQ(kPageID, new_navigation_entry->GetPageID());
-  EXPECT_EQ(content::PAGE_TRANSITION_RELOAD,
+  EXPECT_EQ(ui::PAGE_TRANSITION_RELOAD,
             new_navigation_entry->GetTransitionType());
   EXPECT_EQ(kHasPostData, new_navigation_entry->GetHasPostData());
   EXPECT_EQ(kPostID, new_navigation_entry->GetPostID());
   EXPECT_EQ(kOriginalRequestURL,
             new_navigation_entry->GetOriginalRequestURL());
   EXPECT_EQ(kIsOverridingUserAgent,
             new_navigation_entry->GetIsOverridingUserAgent());
   base::string16 search_terms;
   new_navigation_entry->GetExtraData(kSearchTermsKey, &search_terms);
   EXPECT_EQ(kSearchTerms, search_terms);
@@ skipping 63 matching lines @@
             sync_data.navigation_redirect(0).url());
   EXPECT_EQ(navigation_entry->GetRedirectChain()[1].spec(),
             sync_data.navigation_redirect(1).url());
 }
 
 // Ensure all transition types and qualifiers are converted to/from the sync
 // SerializedNavigationEntry representation properly.
 TEST(SerializedNavigationEntryTest, TransitionTypes) {
   scoped_ptr<content::NavigationEntry> navigation_entry(
       MakeNavigationEntryForTest());
-  for (uint32 core_type = content::PAGE_TRANSITION_LINK;
-       core_type != content::PAGE_TRANSITION_LAST_CORE; ++core_type) {
+  for (uint32 core_type = ui::PAGE_TRANSITION_LINK;
+       core_type != ui::PAGE_TRANSITION_LAST_CORE; ++core_type) {
     // Because qualifier is a uint32, left shifting will eventually overflow
     // and hit zero again. SERVER_REDIRECT, as the last qualifier and also
     // in place of the sign bit, is therefore the last transition before
     // breaking.
-    for (uint32 qualifier = content::PAGE_TRANSITION_FORWARD_BACK;
+    for (uint32 qualifier = ui::PAGE_TRANSITION_FORWARD_BACK;
          qualifier != 0; qualifier <<= 1) {
       if (qualifier == 0x08000000)
         continue;  // 0x08000000 is not a valid qualifier.
-      content::PageTransition transition =
-          static_cast<content::PageTransition>(core_type | qualifier);
+      ui::PageTransition transition =
+          ui::PageTransitionFromInt(core_type | qualifier);
 
       navigation_entry->SetTransitionType(transition);
       const SerializedNavigationEntry& navigation =
           SerializedNavigationEntry::FromNavigationEntry(kIndex,
                                                          *navigation_entry);
       const sync_pb::TabNavigation& sync_data = navigation.ToSyncData();
       const SerializedNavigationEntry& constructed_nav =
           SerializedNavigationEntry::FromSyncData(kIndex, sync_data);
-      const content::PageTransition constructed_transition =
+      const ui::PageTransition constructed_transition =
           constructed_nav.transition_type();
 
       EXPECT_EQ(transition, constructed_transition);
     }
   }
 }
 
 // Tests that the input data is sanitized when a SerializedNavigationEntry
 // is created from a pickle format.
 TEST(SerializedNavigationEntryTest, Sanitize) {
@@ skipping 23 matching lines @@
   EXPECT_EQ(kSearchTerms, navigation.search_terms());
   EXPECT_EQ(kFaviconURL, navigation.favicon_url());
   EXPECT_EQ(kHttpStatusCode, navigation.http_status_code());
 
   content::PageState empty_state;
   EXPECT_TRUE(empty_state.Equals(empty_state.RemoveReferrer()));
 }
 
 }  // namespace
 }  // namespace sessions