Currently, there is a bug in the way we show the csd phishing interstitial.

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/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "base/task.h"
@@ skipping 55 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockClientSideDetectionService);
 };
 
 class MockSafeBrowsingService : public SafeBrowsingService {
  public:
   MockSafeBrowsingService() {}
   virtual ~MockSafeBrowsingService() {}
 
-  MOCK_METHOD8(DisplayBlockingPage,
-               void(const GURL&, const GURL&, const std::vector<GURL>&,
-                    ResourceType::Type, UrlCheckResult, Client*, int, int));
+  MOCK_METHOD1(DoDisplayBlockingPage, void(const UnsafeResource& resource));
   MOCK_METHOD1(MatchCsdWhitelistUrl, bool(const GURL&));
 
   // Helper function which calls OnBlockingPageComplete for this client
   // object.
   void InvokeOnBlockingPageComplete(SafeBrowsingService::Client* client) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     DCHECK(client);
     // Note: this will delete the client object in the case of the CsdClient
     // implementation.
     client->OnBlockingPageComplete(false);
@@ skipping 146 matching lines @@
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
       .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
   OnDetectedPhishingSite(verdict.SerializeAsString());
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
 
-  // Make sure DisplayBlockingPage is not going to be called.
-  EXPECT_CALL(*sb_service_,
-              DisplayBlockingPage(_, _, _, _, _, _, _, _)).Times(0);
+  // Make sure DoDisplayBlockingPage is not going to be called.
+  EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_)).Times(0);
   cb->Run(GURL(verdict.url()), false);
   delete cb;
-  // If there was a message posted on the IO thread to display the
-  // interstitial page we know that it would have been posted before
-  // we put the quit message there.
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          NewRunnableFunction(&QuitUIMessageLoop));
-  MessageLoop::current()->Run();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
 }
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteDisabled) {
   // Case 2: client thinks the page is phishing and so does the server but
   // showing the interstitial is disabled => no interstitial is shown.
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb;
   ClientPhishingRequest verdict;
   verdict.set_url("http://phishingurl.com/");
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
       .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
   OnDetectedPhishingSite(verdict.SerializeAsString());
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
 
-  // Make sure DisplayBlockingPage is not going to be called.
-  EXPECT_CALL(*sb_service_,
-              DisplayBlockingPage(_, _, _, _, _, _, _, _)).Times(0);
+  // Make sure DoDisplayBlockingPage is not going to be called.
+  EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_)).Times(0);
   cb->Run(GURL(verdict.url()), false);
   delete cb;
-
-  FlushIOMessageLoop();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
 }
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteShowInterstitial) {
   // Case 3: client thinks the page is phishing and so does the server.
   // We show an interstitial.
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb;
   GURL phishing_url("http://phishingurl.com/");
   ClientPhishingRequest verdict;
   verdict.set_url(phishing_url.spec());
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableClientSidePhishingInterstitial);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
       .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
   OnDetectedPhishingSite(verdict.SerializeAsString());
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
 
-  SafeBrowsingService::Client* client;
-  EXPECT_CALL(*sb_service_,
-              DisplayBlockingPage(
-                  phishing_url,
-                  phishing_url,
-                  _,
-                  ResourceType::MAIN_FRAME,
-                  SafeBrowsingService::CLIENT_SIDE_PHISHING_URL,
-                  _ /* a CsdClient object */,
-                  contents()->GetRenderProcessHost()->id(),
-                  contents()->render_view_host()->routing_id()))
-      .WillOnce(SaveArg<5>(&client));
-
+  SafeBrowsingService::UnsafeResource resource;
+  EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_))
+      .WillOnce(SaveArg<0>(&resource));
   cb->Run(phishing_url, true);
   delete cb;
 
-  FlushIOMessageLoop();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
+  EXPECT_EQ(phishing_url, resource.url);
+  EXPECT_EQ(phishing_url, resource.original_url);
+  EXPECT_EQ(ResourceType::MAIN_FRAME, resource.resource_type);
+  EXPECT_EQ(SafeBrowsingService::CLIENT_SIDE_PHISHING_URL,
+            resource.threat_type);
+  EXPECT_EQ(contents()->GetRenderProcessHost()->id(),
+            resource.render_process_host_id);
+  EXPECT_EQ(contents()->render_view_host()->routing_id(),
+            resource.render_view_id);
 
   // Make sure the client object will be deleted.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       NewRunnableMethod(
           sb_service_.get(),
           &MockSafeBrowsingService::InvokeOnBlockingPageComplete,
-          client));
+          resource.client));
   // Since the CsdClient object will be deleted on the UI thread I need
   // to run the UI message loop.  Post a task to stop the UI message loop
   // after the client object destructor is called.
   FlushIOMessageLoop();
 }
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteMultiplePings) {
   // Case 4 & 5: client thinks a page is phishing then navigates to
   // another page which is also considered phishing by the client
   // before the server responds with a verdict.  After a while the
@@ skipping 28 matching lines @@
   verdict.set_client_score(0.8f);
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
       .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb_other)));
   OnDetectedPhishingSite(verdict.SerializeAsString());
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb_other);
 
   // We expect that the interstitial is shown for the second phishing URL and
   // not for the first phishing URL.
-  EXPECT_CALL(*sb_service_,
-              DisplayBlockingPage(phishing_url, phishing_url,_, _, _, _, _, _))
-      .Times(0);
-  SafeBrowsingService::Client* client;
-  EXPECT_CALL(*sb_service_,
-              DisplayBlockingPage(
-                  other_phishing_url,
-                  other_phishing_url,
-                  _,
-                  ResourceType::MAIN_FRAME,
-                  SafeBrowsingService::CLIENT_SIDE_PHISHING_URL,
-                  _ /* a CsdClient object */,
-                  contents()->GetRenderProcessHost()->id(),
-                  contents()->render_view_host()->routing_id()))
-      .WillOnce(SaveArg<5>(&client));
-
+  SafeBrowsingService::UnsafeResource resource;
+  EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_))
+      .WillOnce(SaveArg<0>(&resource));
   cb->Run(phishing_url, true);  // Should have no effect.
   delete cb;
   cb_other->Run(other_phishing_url, true);  // Should show interstitial.
   delete cb_other;
 
-  FlushIOMessageLoop();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
+  EXPECT_EQ(other_phishing_url, resource.url);
+  EXPECT_EQ(other_phishing_url, resource.original_url);
+  EXPECT_EQ(ResourceType::MAIN_FRAME, resource.resource_type);
+  EXPECT_EQ(SafeBrowsingService::CLIENT_SIDE_PHISHING_URL,
+            resource.threat_type);
+  EXPECT_EQ(contents()->GetRenderProcessHost()->id(),
+            resource.render_process_host_id);
+  EXPECT_EQ(contents()->render_view_host()->routing_id(),
+            resource.render_view_id);
 
   // Make sure the client object will be deleted.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       NewRunnableMethod(
           sb_service_.get(),
           &MockSafeBrowsingService::InvokeOnBlockingPageComplete,
-          client));
+          resource.client));
   // Since the CsdClient object will be deleted on the UI thread I need
   // to run the UI message loop.  Post a task to stop the UI message loop
   // after the client object destructor is called.
   FlushIOMessageLoop();
 }
 
 TEST_F(ClientSideDetectionHostTest, NavigationCancelsShouldClassifyUrl) {
   // Test that canceling pending should classify requests works as expected.
 
   GURL first_url("http://first.phishy.url.com");
@@ skipping 153 matching lines @@
       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>());
+
+  SafeBrowsingService::UnsafeResource resource;
+  EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_))
+      .WillOnce(SaveArg<0>(&resource));
+
   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()));
+  EXPECT_EQ(url, resource.url);
+  EXPECT_EQ(url, resource.original_url);
+  delete resource.client;
   msg = process()->sink().GetFirstMessageMatching(
       SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 }
 
 }  // namespace safe_browsing