Rename HistoryService::NotifyRenderProcessHostDestruction

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 883 matching lines @@
     EXPECT_TRUE(found)
         << "Error \"" << cur_reason.name << "\" not found in historical list."
         << std::endl
         << "Please add it.";
   }
 }
 
 // The tracker uses RenderProcessHost pointers for scoping but never
 // dereferences them. We use ints because it's easier. This function converts
 // between the two.
-static void* MakeFakeHost(int id) {
-  void* host = 0;
-  memcpy(&host, &id, sizeof(id));
-  return host;
+static void* MakeFakeContextID(int id) {
+  ContextID context_id = 0;

[sdefresne, 2014/06/10 15:51:54]

nit: can't this function be replaced with "ContextID context_id =
reinterpret_cast<ContextID>(id);"?

[方觉(Fang Jue), 2014/06/11 12:41:46]

n 2014/06/10 15:51:54, sdefresne wrote:
I looked at the history of this file and it was written in this way since the
beginning. Some other unittest files simply use reinterpret_cast.

Google C++ Style says 'Use reinterpret_cast to do unsafe conversions of pointer
types to and from integer and other pointer types. Use this only if you know
what you are doing and you understand the aliasing issues.' It seems that we can
use reinterpret_cast here.

+  memcpy(&context_id, &id, sizeof(id));
+  return context_id;
 }
 
 class HistoryTest : public testing::Test {
  public:
   HistoryTest()
       : got_thumbnail_callback_(false),
         redirect_query_success_(false),
         query_url_success_(false) {
   }
 
@@ skipping 38 matching lines @@
     // Make sure we don't have any event pending that could disrupt the next
     // test.
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
   }
 
   void CleanupHistoryService() {
     DCHECK(history_service_);
 
-    history_service_->NotifyRenderProcessHostDestruction(0);
+    history_service_->ClearCachedDataForContextID(0);
     history_service_->SetOnBackendDestroyTask(base::MessageLoop::QuitClosure());
     history_service_->Cleanup();
     history_service_.reset();
 
     // Wait for the backend class to terminate before deleting the files and
     // moving to the next test. Note: if this never terminates, somebody is
     // probably leaking a reference to the history backend, so it never calls
     // our destroy task.
     base::MessageLoop::current()->Run();
   }
@@ skipping 114 matching lines @@
     "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(), MakeFakeHost(1),
+      first_redirects.back(), base::Time::Now(), MakeFakeContextID(1),
       0, GURL(), first_redirects, content::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 |
@@ skipping 18 matching lines @@
   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(),
-                   MakeFakeHost(1), 1, second_redirects[0], second_redirects,
+                   MakeFakeContextID(1), 1,
+                   second_redirects[0], second_redirects,
                    static_cast<content::PageTransition>(
                        content::PAGE_TRANSITION_LINK |
                        content::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());
@@ skipping 169 matching lines @@
   EXPECT_EQ(base::string16(), query_url_row_.title());
 
   // TODO(brettw) this should also test redirects, which get the title of the
   // destination page.
 }
 
 // crbug.com/159387: This test fails when daylight savings time ends.
 TEST_F(HistoryTest, DISABLED_Segments) {
   ASSERT_TRUE(history_service_.get());
 
-  static const void* scope = static_cast<void*>(this);
+  static ContextID context_id = static_cast<ContextID>(this);
 
   // Add a URL.
   const GURL existing_url("http://www.google.com/");
   history_service_->AddPage(
-      existing_url, base::Time::Now(), scope, 0, GURL(),
+      existing_url, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
 
   // Make sure a segment was created.
   history_service_->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   base::MessageLoop::current()->Run();
 
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
   EXPECT_DOUBLE_EQ(3.0, page_usage_data_[0]->GetScore());
 
   // Add a URL which doesn't create a segment.
   const GURL link_url("http://yahoo.com/");
   history_service_->AddPage(
-      link_url, base::Time::Now(), scope, 0, GURL(),
+      link_url, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
 
   // Query again
   history_service_->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   base::MessageLoop::current()->Run();
 
   // Make sure we still have one segment.
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
 
   // Add a page linked from existing_url.
   history_service_->AddPage(
       GURL("http://www.google.com/foo"), base::Time::Now(),
-      scope, 3, existing_url, history::RedirectList(),
+      context_id, 3, existing_url, history::RedirectList(),
       content::PAGE_TRANSITION_LINK, history::SOURCE_BROWSED,
       false);
 
   // Query again
   history_service_->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
   base::MessageLoop::current()->Run();
 
   // Make sure we still have one segment.
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
 
   // However, the score should have increased.
   EXPECT_GT(page_usage_data_[0]->GetScore(), 5.0);
 }
 
 TEST_F(HistoryTest, MostVisitedURLs) {
   ASSERT_TRUE(history_service_.get());
 
   const GURL url0("http://www.google.com/url0/");
   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/");
 
-  static const void* scope = static_cast<void*>(this);
+  static ContextID context_id = static_cast<ContextID>(this);
 
   // Add two pages.
   history_service_->AddPage(
-      url0, base::Time::Now(), scope, 0, GURL(),
+      url0, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->AddPage(
-      url1, base::Time::Now(), scope, 0, GURL(),
+      url1, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
   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(), scope, 0, GURL(),
+      url2, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
   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(), scope, 0, GURL(),
+      url2, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
   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(), scope, 0, GURL(),
+      url1, base::Time::Now(), context_id, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
   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(), scope, 0, GURL(),
+      url4, base::Time::Now(), context_id, 0, GURL(),
       redirects, content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(4U, most_visited_urls_.size());
@@ skipping 372 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