Untyped intranet URL check should examine the start and end of a redirect chain.

components/history/core/browser/history_service_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 186 matching lines @@
                    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(HistoryServiceTest, 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]));
+  history::RedirectList first_redirects = {GURL("http://first.page.com/"),
+                                           GURL("http://second.page.com/")};
 
   // 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,
       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).
@@ skipping 21 matching lines @@
 
   // 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::RedirectList second_redirects = {first_redirects[1],
+                                            GURL("http://last.page.com/")};
   history_service_->AddPage(second_redirects[1], base::Time::Now(),
                    reinterpret_cast<ContextID>(1), 1,
                    second_redirects[0], second_redirects,
                    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
@@ skipping 89 matching lines @@
   history_service_->AddPage(
       test_url, base::Time::Now(), NULL, 0, GURL(),
       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_TRUE(ui::PageTransitionCoreTypeIs(query_url_visits_[1].transition,
                                            ui::PAGE_TRANSITION_LINK));
+
+  // A redirect chain with an intranet URL at the head should be promoted.
+  history::RedirectList redirects1 = {GURL("http://intranet1/path"),
+                                      GURL("http://second1.com/"),
+                                      GURL("http://third1.com/")};
+  history_service_->AddPage(redirects1.back(), base::Time::Now(), NULL, 0,
+                            GURL(), redirects1, ui::PAGE_TRANSITION_LINK,
+                            history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history_service_.get(), redirects1.front()));
+  EXPECT_EQ(1, query_url_row_.visit_count());
+  EXPECT_EQ(1, query_url_row_.typed_count());
+  ASSERT_EQ(1U, query_url_visits_.size());
+  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(query_url_visits_[0].transition,
+                                           ui::PAGE_TRANSITION_TYPED));
+
+  // As should one with an intranet URL at the tail.
+  history::RedirectList redirects2 = {GURL("http://first2.com/"),
+                                      GURL("http://second2.com/"),
+                                      GURL("http://intranet2/path")};
+  history_service_->AddPage(redirects2.back(), base::Time::Now(), NULL, 0,
+                            GURL(), redirects2, ui::PAGE_TRANSITION_LINK,
+                            history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history_service_.get(), redirects2.back()));
+  EXPECT_EQ(1, query_url_row_.visit_count());
+  EXPECT_EQ(0, query_url_row_.typed_count());
+  ASSERT_EQ(1U, query_url_visits_.size());
+  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(query_url_visits_[0].transition,
+                                           ui::PAGE_TRANSITION_TYPED));
+
+  // But not one with an intranet URL in the middle.
+  history::RedirectList redirects3 = {GURL("http://first3.com/"),
+                                      GURL("http://intranet3/path"),
+                                      GURL("http://third3.com/")};
+  history_service_->AddPage(redirects3.back(), base::Time::Now(), NULL, 0,
+                            GURL(), redirects3, ui::PAGE_TRANSITION_LINK,
+                            history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history_service_.get(), redirects3[1]));
+  EXPECT_EQ(1, query_url_row_.visit_count());
+  EXPECT_EQ(0, query_url_row_.typed_count());
+  ASSERT_EQ(1U, query_url_visits_.size());
+  EXPECT_TRUE(ui::PageTransitionCoreTypeIs(query_url_visits_[0].transition,
+                                           ui::PAGE_TRANSITION_LINK));
 }
 
 TEST_F(HistoryServiceTest, 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(
@@ skipping 148 matching lines @@
       base::Bind(&HistoryServiceTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
   base::RunLoop().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::RedirectList redirects = {url3, url4};
   history_service_->AddPage(
       url4, base::Time::Now(), context_id, 0, GURL(),
       redirects, ui::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20,
       90,
       base::Bind(&HistoryServiceTest::OnMostVisitedURLsAvailable,
                  base::Unretained(this)),
       &tracker_);
@@ skipping 311 matching lines @@
   // Expect two sync changes for deleting processed directives.
   const syncer::SyncChangeList& sync_changes = change_processor.changes();
   ASSERT_EQ(2u, sync_changes.size());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[0].change_type());
   EXPECT_EQ(1, syncer::SyncDataRemote(sync_changes[0].sync_data()).GetId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, syncer::SyncDataRemote(sync_changes[1].sync_data()).GetId());
 }
 
 }  // namespace history