| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/sessions/serialized_navigation_entry.h" | |
| 6 | |
| 7 #include <cstddef> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/memory/scoped_ptr.h" | |
| 12 #include "base/pickle.h" | |
| 13 #include "base/strings/string16.h" | |
| 14 #include "base/strings/string_number_conversions.h" | |
| 15 #include "base/strings/utf_string_conversions.h" | |
| 16 #include "base/time/time.h" | |
| 17 #include "components/sessions/core/serialized_navigation_driver.h" | |
| 18 #include "components/sessions/serialized_navigation_entry_test_helper.h" | |
| 19 #include "sync/protocol/session_specifics.pb.h" | |
| 20 #include "sync/util/time.h" | |
| 21 #include "testing/gtest/include/gtest/gtest.h" | |
| 22 #include "ui/base/page_transition_types.h" | |
| 23 #include "url/gurl.h" | |
| 24 | |
| 25 namespace sessions { | |
| 26 namespace { | |
| 27 | |
| 28 // Create a sync_pb::TabNavigation from the constants above. | |
| 29 sync_pb::TabNavigation MakeSyncDataForTest() { | |
| 30 sync_pb::TabNavigation sync_data; | |
| 31 sync_data.set_virtual_url(test_data::kVirtualURL.spec()); | |
| 32 sync_data.set_referrer(test_data::kReferrerURL.spec()); | |
| 33 sync_data.set_obsolete_referrer_policy(test_data::kReferrerPolicy); | |
| 34 sync_data.set_correct_referrer_policy(test_data::kReferrerPolicy); | |
| 35 sync_data.set_title(base::UTF16ToUTF8(test_data::kTitle)); | |
| 36 sync_data.set_state(test_data::kEncodedPageState); | |
| 37 sync_data.set_page_transition( | |
| 38 sync_pb::SyncEnums_PageTransition_AUTO_SUBFRAME); | |
| 39 sync_data.set_unique_id(test_data::kUniqueID); | |
| 40 sync_data.set_timestamp_msec(syncer::TimeToProtoTime(test_data::kTimestamp)); | |
| 41 sync_data.set_redirect_type(sync_pb::SyncEnums::CLIENT_REDIRECT); | |
| 42 sync_data.set_navigation_home_page(true); | |
| 43 sync_data.set_search_terms(base::UTF16ToUTF8(test_data::kSearchTerms)); | |
| 44 sync_data.set_favicon_url(test_data::kFaviconURL.spec()); | |
| 45 sync_data.set_http_status_code(test_data::kHttpStatusCode); | |
| 46 // The redirect chain only syncs one way. | |
| 47 return sync_data; | |
| 48 } | |
| 49 | |
| 50 // Create a default SerializedNavigationEntry. All its fields should be | |
| 51 // initialized to their respective default values. | |
| 52 TEST(SerializedNavigationEntryTest, DefaultInitializer) { | |
| 53 const SerializedNavigationEntry navigation; | |
| 54 EXPECT_EQ(-1, navigation.index()); | |
| 55 EXPECT_EQ(0, navigation.unique_id()); | |
| 56 EXPECT_EQ(GURL(), navigation.referrer_url()); | |
| 57 EXPECT_EQ( | |
| 58 SerializedNavigationDriver::Get()->GetDefaultReferrerPolicy(), | |
| 59 navigation.referrer_policy()); | |
| 60 EXPECT_EQ(GURL(), navigation.virtual_url()); | |
| 61 EXPECT_TRUE(navigation.title().empty()); | |
| 62 EXPECT_EQ(std::string(), navigation.encoded_page_state()); | |
| 63 EXPECT_EQ(ui::PAGE_TRANSITION_TYPED, navigation.transition_type()); | |
| 64 EXPECT_FALSE(navigation.has_post_data()); | |
| 65 EXPECT_EQ(-1, navigation.post_id()); | |
| 66 EXPECT_EQ(GURL(), navigation.original_request_url()); | |
| 67 EXPECT_FALSE(navigation.is_overriding_user_agent()); | |
| 68 EXPECT_TRUE(navigation.timestamp().is_null()); | |
| 69 EXPECT_TRUE(navigation.search_terms().empty()); | |
| 70 EXPECT_FALSE(navigation.favicon_url().is_valid()); | |
| 71 EXPECT_EQ(0, navigation.http_status_code()); | |
| 72 EXPECT_EQ(0U, navigation.redirect_chain().size()); | |
| 73 } | |
| 74 | |
| 75 // Create a SerializedNavigationEntry from a sync_pb::TabNavigation. All its | |
| 76 // fields should match the protocol buffer's if it exists there, and | |
| 77 // sbould be set to the default value otherwise. | |
| 78 TEST(SerializedNavigationEntryTest, FromSyncData) { | |
| 79 const sync_pb::TabNavigation sync_data = MakeSyncDataForTest(); | |
| 80 | |
| 81 const SerializedNavigationEntry& navigation = | |
| 82 SerializedNavigationEntry::FromSyncData(test_data::kIndex, sync_data); | |
| 83 | |
| 84 EXPECT_EQ(test_data::kIndex, navigation.index()); | |
| 85 EXPECT_EQ(test_data::kUniqueID, navigation.unique_id()); | |
| 86 EXPECT_EQ(test_data::kReferrerURL, navigation.referrer_url()); | |
| 87 EXPECT_EQ(test_data::kReferrerPolicy, navigation.referrer_policy()); | |
| 88 EXPECT_EQ(test_data::kVirtualURL, navigation.virtual_url()); | |
| 89 EXPECT_EQ(test_data::kTitle, navigation.title()); | |
| 90 EXPECT_EQ(test_data::kEncodedPageState, navigation.encoded_page_state()); | |
| 91 EXPECT_EQ(test_data::kTransitionType, navigation.transition_type()); | |
| 92 EXPECT_FALSE(navigation.has_post_data()); | |
| 93 EXPECT_EQ(-1, navigation.post_id()); | |
| 94 EXPECT_EQ(GURL(), navigation.original_request_url()); | |
| 95 EXPECT_FALSE(navigation.is_overriding_user_agent()); | |
| 96 EXPECT_TRUE(navigation.timestamp().is_null()); | |
| 97 EXPECT_EQ(test_data::kSearchTerms, navigation.search_terms()); | |
| 98 EXPECT_EQ(test_data::kFaviconURL, navigation.favicon_url()); | |
| 99 EXPECT_EQ(test_data::kHttpStatusCode, navigation.http_status_code()); | |
| 100 // The redirect chain only syncs one way. | |
| 101 } | |
| 102 | |
| 103 // Create a SerializedNavigationEntry, pickle it, then create another one by | |
| 104 // unpickling. The new one should match the old one except for fields | |
| 105 // that aren't pickled, which should be set to default values. | |
| 106 TEST(SerializedNavigationEntryTest, Pickle) { | |
| 107 const SerializedNavigationEntry old_navigation = | |
| 108 SerializedNavigationEntryTestHelper::CreateNavigationForTest(); | |
| 109 | |
| 110 base::Pickle pickle; | |
| 111 old_navigation.WriteToPickle(30000, &pickle); | |
| 112 | |
| 113 SerializedNavigationEntry new_navigation; | |
| 114 base::PickleIterator pickle_iterator(pickle); | |
| 115 EXPECT_TRUE(new_navigation.ReadFromPickle(&pickle_iterator)); | |
| 116 | |
| 117 // Fields that are written to the pickle. | |
| 118 EXPECT_EQ(test_data::kIndex, new_navigation.index()); | |
| 119 EXPECT_EQ(test_data::kReferrerURL, new_navigation.referrer_url()); | |
| 120 EXPECT_EQ(test_data::kReferrerPolicy, new_navigation.referrer_policy()); | |
| 121 EXPECT_EQ(test_data::kVirtualURL, new_navigation.virtual_url()); | |
| 122 EXPECT_EQ(test_data::kTitle, new_navigation.title()); | |
| 123 EXPECT_EQ(test_data::kTransitionType, new_navigation.transition_type()); | |
| 124 EXPECT_EQ(test_data::kHasPostData, new_navigation.has_post_data()); | |
| 125 EXPECT_EQ(test_data::kOriginalRequestURL, | |
| 126 new_navigation.original_request_url()); | |
| 127 EXPECT_EQ(test_data::kIsOverridingUserAgent, | |
| 128 new_navigation.is_overriding_user_agent()); | |
| 129 EXPECT_EQ(test_data::kTimestamp, new_navigation.timestamp()); | |
| 130 EXPECT_EQ(test_data::kSearchTerms, new_navigation.search_terms()); | |
| 131 EXPECT_EQ(test_data::kHttpStatusCode, new_navigation.http_status_code()); | |
| 132 | |
| 133 // Fields that are not written to the pickle. | |
| 134 EXPECT_EQ(0, new_navigation.unique_id()); | |
| 135 EXPECT_EQ(std::string(), new_navigation.encoded_page_state()); | |
| 136 EXPECT_EQ(-1, new_navigation.post_id()); | |
| 137 EXPECT_EQ(0U, new_navigation.redirect_chain().size()); | |
| 138 } | |
| 139 | |
| 140 // Create a SerializedNavigationEntry, then create a sync protocol buffer from | |
| 141 // it. The protocol buffer should have matching fields to the | |
| 142 // SerializedNavigationEntry (when applicable). | |
| 143 TEST(SerializedNavigationEntryTest, ToSyncData) { | |
| 144 const SerializedNavigationEntry navigation = | |
| 145 SerializedNavigationEntryTestHelper::CreateNavigationForTest(); | |
| 146 const sync_pb::TabNavigation sync_data = navigation.ToSyncData(); | |
| 147 | |
| 148 EXPECT_EQ(test_data::kVirtualURL.spec(), sync_data.virtual_url()); | |
| 149 EXPECT_EQ(test_data::kReferrerURL.spec(), sync_data.referrer()); | |
| 150 EXPECT_EQ(test_data::kTitle, base::ASCIIToUTF16(sync_data.title())); | |
| 151 EXPECT_TRUE(sync_data.state().empty()); | |
| 152 EXPECT_EQ(sync_pb::SyncEnums_PageTransition_AUTO_SUBFRAME, | |
| 153 sync_data.page_transition()); | |
| 154 EXPECT_TRUE(sync_data.has_redirect_type()); | |
| 155 EXPECT_EQ(test_data::kUniqueID, sync_data.unique_id()); | |
| 156 EXPECT_EQ(syncer::TimeToProtoTime(test_data::kTimestamp), | |
| 157 sync_data.timestamp_msec()); | |
| 158 EXPECT_EQ(test_data::kTimestamp.ToInternalValue(), sync_data.global_id()); | |
| 159 EXPECT_EQ(test_data::kFaviconURL.spec(), sync_data.favicon_url()); | |
| 160 EXPECT_EQ(test_data::kHttpStatusCode, sync_data.http_status_code()); | |
| 161 // The proto navigation redirects don't include the final chain entry | |
| 162 // (because it didn't redirect) so the lengths should differ by 1. | |
| 163 ASSERT_EQ(3, sync_data.navigation_redirect_size() + 1); | |
| 164 EXPECT_EQ(test_data::kRedirectURL0.spec(), | |
| 165 sync_data.navigation_redirect(0).url()); | |
| 166 EXPECT_EQ(test_data::kRedirectURL1.spec(), | |
| 167 sync_data.navigation_redirect(1).url()); | |
| 168 EXPECT_FALSE(sync_data.has_last_navigation_redirect_url()); | |
| 169 } | |
| 170 | |
| 171 // Test that the last_navigation_redirect_url is set when needed. This test is | |
| 172 // just like the above, but with a different virtual_url. Create a | |
| 173 // SerializedNavigationEntry, then create a sync protocol buffer from it. The | |
| 174 // protocol buffer should have a last_navigation_redirect_url. | |
| 175 TEST(SerializedNavigationEntryTest, LastNavigationRedirectUrl) { | |
| 176 SerializedNavigationEntry navigation = | |
| 177 SerializedNavigationEntryTestHelper::CreateNavigationForTest(); | |
| 178 SerializedNavigationEntryTestHelper::SetVirtualURL( | |
| 179 test_data::kOtherURL, &navigation); | |
| 180 | |
| 181 const sync_pb::TabNavigation sync_data = navigation.ToSyncData(); | |
| 182 EXPECT_TRUE(sync_data.has_last_navigation_redirect_url()); | |
| 183 EXPECT_EQ(test_data::kVirtualURL.spec(), | |
| 184 sync_data.last_navigation_redirect_url()); | |
| 185 | |
| 186 // The redirect chain should be the same as in the above test. | |
| 187 ASSERT_EQ(3, sync_data.navigation_redirect_size() + 1); | |
| 188 EXPECT_EQ(test_data::kRedirectURL0.spec(), | |
| 189 sync_data.navigation_redirect(0).url()); | |
| 190 EXPECT_EQ(test_data::kRedirectURL1.spec(), | |
| 191 sync_data.navigation_redirect(1).url()); | |
| 192 } | |
| 193 | |
| 194 // Ensure all transition types and qualifiers are converted to/from the sync | |
| 195 // SerializedNavigationEntry representation properly. | |
| 196 TEST(SerializedNavigationEntryTest, TransitionTypes) { | |
| 197 SerializedNavigationEntry navigation = | |
| 198 SerializedNavigationEntryTestHelper::CreateNavigationForTest(); | |
| 199 | |
| 200 for (uint32 core_type = ui::PAGE_TRANSITION_LINK; | |
| 201 core_type != ui::PAGE_TRANSITION_LAST_CORE; ++core_type) { | |
| 202 // Because qualifier is a uint32, left shifting will eventually overflow | |
| 203 // and hit zero again. SERVER_REDIRECT, as the last qualifier and also | |
| 204 // in place of the sign bit, is therefore the last transition before | |
| 205 // breaking. | |
| 206 for (uint32 qualifier = ui::PAGE_TRANSITION_FORWARD_BACK; | |
| 207 qualifier != 0; qualifier <<= 1) { | |
| 208 if (qualifier == 0x08000000) | |
| 209 continue; // 0x08000000 is not a valid qualifier. | |
| 210 ui::PageTransition transition = | |
| 211 ui::PageTransitionFromInt(core_type | qualifier); | |
| 212 SerializedNavigationEntryTestHelper::SetTransitionType( | |
| 213 transition, &navigation); | |
| 214 | |
| 215 const sync_pb::TabNavigation& sync_data = navigation.ToSyncData(); | |
| 216 const SerializedNavigationEntry& constructed_nav = | |
| 217 SerializedNavigationEntry::FromSyncData(test_data::kIndex, sync_data); | |
| 218 const ui::PageTransition constructed_transition = | |
| 219 constructed_nav.transition_type(); | |
| 220 | |
| 221 EXPECT_EQ(transition, constructed_transition); | |
| 222 } | |
| 223 } | |
| 224 } | |
| 225 | |
| 226 } // namespace | |
| 227 } // namespace sessions | |
| OLD | NEW |