Move the rest of the renderer->browser messages that belong in content. Also do a bunch of cleanup:

chrome/browser/safe_browsing/client_side_detection_host_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.
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "base/task.h"
 #include "chrome/browser/safe_browsing/client_side_detection_host.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/render_messages.h"
+#include "chrome/common/safebrowsing_messages.h"
 #include "chrome/test/testing_profile.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/tab_contents/test_tab_contents.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_test_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock/include/gmock/gmock-actions.h"
 #include "testing/gmock/include/gmock/gmock-generated-nice-strict.h"
@@ skipping 381 matching lines @@
 
 TEST_F(ClientSideDetectionHostTest, ShouldClassifyUrl) {
   // Navigate the tab to a page.  We should see a StartPhishingDetection IPC.
   GURL url("http://host.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kFalse, &kFalse, &kFalse,
                                 &kFalse, &kFalse);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
 
   const IPC::Message* msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_TRUE(msg);
   Tuple1<GURL> actual_url;
-  ViewMsg_StartPhishingDetection::Read(msg, &actual_url);
+  SafeBrowsingMsg_StartPhishingDetection::Read(msg, &actual_url);
   EXPECT_EQ(url, actual_url.a);
   EXPECT_EQ(rvh()->routing_id(), msg->routing_id());
   process()->sink().ClearMessages();
 
   // Now try an in-page navigation.  This should not trigger an IPC.
   EXPECT_CALL(*csd_service_, IsPrivateIPAddress(_)).Times(0);
   url = GURL("http://host.com/#foo");
   ExpectPreClassificationChecks(url, NULL, NULL, NULL, NULL, NULL, NULL);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
 
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 
   // Navigate to a new host, which should cause another IPC.
   url = GURL("http://host2.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kFalse, &kFalse, &kFalse,
                                 &kFalse, &kFalse);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_TRUE(msg);
-  ViewMsg_StartPhishingDetection::Read(msg, &actual_url);
+  SafeBrowsingMsg_StartPhishingDetection::Read(msg, &actual_url);
   EXPECT_EQ(url, actual_url.a);
   EXPECT_EQ(rvh()->routing_id(), msg->routing_id());
   process()->sink().ClearMessages();
 
   // If IsPrivateIPAddress returns true, no IPC should be triggered.
   url = GURL("http://host3.com/");
   ExpectPreClassificationChecks(url, &kTrue, NULL, NULL, NULL, NULL, NULL);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 
   // If the connection is proxied, no IPC should be triggered.
   // Note: for this test to work correctly, the new URL must be on the
   // same domain as the previous URL, otherwise it will create a new
   // RenderViewHost that won't have simulate_fetch_via_proxy set.
   url = GURL("http://host3.com/abc");
   rvh()->set_simulate_fetch_via_proxy(true);
   ExpectPreClassificationChecks(url, NULL, NULL, NULL, NULL, NULL, NULL);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 
   // If the tab is off-the-record there should be no IPC.  Also, we shouldn't
   // even check the csd-whitelist.
   url = GURL("http://host4.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kTrue, NULL, NULL, NULL, NULL);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 
   // If the URL is on the csd whitelist, no IPC should be triggered.
   url = GURL("http://host5.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kFalse, &kTrue, NULL, NULL,
                                 NULL);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 
   // If item is in the cache but it isn't valid, we will classify regardless
   // of whether we are over the reporting limit.
   url = GURL("http://host6.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kFalse, &kFalse, &kFalse, &kTrue,
                                 NULL);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_TRUE(msg);
-  ViewMsg_StartPhishingDetection::Read(msg, &actual_url);
+  SafeBrowsingMsg_StartPhishingDetection::Read(msg, &actual_url);
   EXPECT_EQ(url, actual_url.a);
   EXPECT_EQ(rvh()->routing_id(), msg->routing_id());
   process()->sink().ClearMessages();
 
   // If the url isn't in the cache and we are over the reporting limit, we
   // don't do classification.
   url = GURL("http://host7.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kFalse, &kFalse, &kFalse,
                                 &kFalse, &kTrue);
   NavigateAndCommit(url);
   WaitAndCheckPreClassificationChecks();
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 
   // If result is cached, we will try and display the blocking page directly
   // with no start classification message.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableClientSidePhishingInterstitial);
   url = GURL("http://host8.com/");
   ExpectPreClassificationChecks(url, &kFalse, &kFalse, &kFalse, &kTrue, NULL,
                                 NULL);
   EXPECT_CALL(*sb_service_,
               DisplayBlockingPage(Eq(url), Eq(url), _, _, _, _, _, _))
       .WillOnce(DeleteArg<5>());
   NavigateAndCommit(url);
   // Wait for CheckCsdWhitelist to be called on the IO thread.
   FlushIOMessageLoop();
   // Wait for CheckCache() to be called on the UI thread.
   MessageLoop::current()->RunAllPending();
   // Wait for DisplayBlockingPage to be called on the IO thread.
   FlushIOMessageLoop();
   // Now we check that all expected functions were indeed called on the two
   // service objects.
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
   msg = process()->sink().GetFirstMessageMatching(
-      ViewMsg_StartPhishingDetection::ID);
+      SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 }
 
 }  // namespace safe_browsing