When users navigate to an intranet host that has not been previously typed, treat it as a typed n...

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 451 matching lines @@
   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/"};
+    "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->AddPage(first_redirects.back(), MakeFakeHost(1), 0, GURL(),
                    content::PAGE_TRANSITION_LINK, first_redirects,
                    history::SOURCE_BROWSED,  true);
@@ skipping 24 matching lines @@
   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/"));
+  second_redirects.push_back(GURL("http://last.page.com/"));
   history->AddPage(second_redirects[1], MakeFakeHost(1), 1,
                    second_redirects[0],
                    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(content::PAGE_TRANSITION_CLIENT_REDIRECT |
-            content::PAGE_TRANSITION_CHAIN_END, query_url_visits_[0].transition);
+            content::PAGE_TRANSITION_CHAIN_END,
+            query_url_visits_[0].transition);
   EXPECT_EQ(second_visit, query_url_visits_[0].referring_visit);
 }
 
+TEST_F(HistoryTest, MakeIntranetURLsTyped) {
+  scoped_refptr<HistoryService> history(new HistoryService);
+  history_service_ = history;
+  ASSERT_TRUE(history->Init(history_dir_, NULL));
+
+  // 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->AddPage(test_url, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
+                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history, 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));
+
+  // 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->AddPage(test_url2, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
+                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history, 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));
+
+  // No path.
+  const GURL test_url3("http://intranet_host/");
+  history->AddPage(test_url3, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
+                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history, 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));
+
+  // Different scheme.
+  const GURL test_url4("https://intranet_host/");
+  history->AddPage(test_url4, NULL, 0, GURL(), content::PAGE_TRANSITION_LINK,
+                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history, 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));
+
+  // Different transition.
+  const GURL test_url5("http://intranet_host/another_path");
+  history->AddPage(test_url5, NULL, 0, GURL(),
+                   content::PAGE_TRANSITION_AUTO_BOOKMARK,
+                   history::RedirectList(), history::SOURCE_BROWSED, false);
+  EXPECT_TRUE(QueryURL(history, 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));
+
+  // Original URL.
+  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());
+  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));
+}
+
 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(), content::PAGE_TRANSITION_TYPED,
                    history::RedirectList(),
                    history::SOURCE_BROWSED, false);
@@ skipping 320 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