[SafeBrowsing] Reset malware indicator on page nav start.

chrome/browser/safe_browsing/client_side_detection_host_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.
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 30 matching lines @@
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using content::BrowserThread;
 using content::RenderViewHostTester;
 using content::WebContents;
 
 namespace {
+
 const bool kFalse = false;
 const bool kTrue = true;
-}
+
+}  // namespace
 
 namespace safe_browsing {
 namespace {
 // This matcher verifies that the client computed verdict
 // (ClientPhishingRequest) which is passed to SendClientReportPhishingRequest
 // has the expected fields set.  Note: we can't simply compare the protocol
 // buffer strings because the BrowserFeatureExtractor might add features to the
 // verdict object before calling SendClientReportPhishingRequest.
 MATCHER_P(PartiallyEqualVerdict, other, "") {
   return (other.url() == arg.url() &&
@@ skipping 299 matching lines @@
     resource.original_url = url;
     resource.is_subresource = false;
     resource.threat_type = SB_THREAT_TYPE_URL_MALWARE;
     resource.callback = base::Bind(&EmptyUrlCheckCallback);
     resource.render_process_host_id = pending_rvh()->GetProcess()->GetID();
     resource.render_view_id = pending_rvh()->GetRoutingID();
     csd_host_->OnSafeBrowsingMatch(resource);
     csd_host_->OnSafeBrowsingHit(resource);
     resource.callback.Reset();
 
+    ASSERT_TRUE(csd_host_->DidPageReceiveSafeBrowsingMatch());
+
     // LoadURL created a navigation entry, now simulate the RenderView sending
     // a notification that it actually navigated.
     content::WebContentsTester::For(web_contents())->CommitPendingNavigation();
 
     ASSERT_TRUE(csd_host_->DidPageReceiveSafeBrowsingMatch());
     ASSERT_TRUE(csd_host_->DidShowSBInterstitial());
     TestUnsafeResourceCopied(resource);
   }
 
+  void NavigateWithoutSBHitAndCommit(const GURL& safe_url) {
+    controller().LoadURL(
+        safe_url, content::Referrer(), content::PAGE_TRANSITION_LINK,
+        std::string());
+
+    ASSERT_TRUE(pending_rvh());
+    if (web_contents()->GetRenderViewHost()->GetProcess()->GetID() ==
+        pending_rvh()->GetProcess()->GetID()) {
+      EXPECT_NE(web_contents()->GetRenderViewHost()->GetRoutingID(),
+                pending_rvh()->GetRoutingID());
+    }
+    ASSERT_FALSE(csd_host_->DidPageReceiveSafeBrowsingMatch());
+    ASSERT_FALSE(csd_host_->DidShowSBInterstitial());
+
+    content::WebContentsTester::For(web_contents())->CommitPendingNavigation();
+    ASSERT_FALSE(csd_host_->DidPageReceiveSafeBrowsingMatch());
+    ASSERT_FALSE(csd_host_->DidShowSBInterstitial());
+  }
+
   void CheckIPUrlEqual(const std::vector<IPUrlInfo>& expect,
                        const std::vector<IPUrlInfo>& result) {
     ASSERT_EQ(expect.size(), result.size());
 
     for (unsigned int i = 0; i < expect.size(); ++i) {
       EXPECT_EQ(expect[i].url, result[i].url);
       EXPECT_EQ(expect[i].method, result[i].method);
       EXPECT_EQ(expect[i].referrer, result[i].referrer);
       EXPECT_EQ(expect[i].resource_type, result[i].resource_type);
     }
@@ skipping 332 matching lines @@
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(
                   Pointee(PartiallyEqualVerdict(verdict)), CallbackIsNull()))
       .WillOnce(DoAll(DeleteArg<0>(), QuitUIMessageLoop()));
   std::vector<GURL> redirect_chain;
   redirect_chain.push_back(url);
   SetRedirectChain(redirect_chain);
   OnPhishingDetectionDone(verdict.SerializeAsString());
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_host_.get()));
+
+  ExpectPreClassificationChecks(start_url, &kFalse, &kFalse, &kFalse, &kFalse,
+                                &kFalse, &kFalse);
+  NavigateWithoutSBHitAndCommit(start_url);
+  WaitAndCheckPreClassificationChecks();
 }
 
 TEST_F(ClientSideDetectionHostTest, UpdateIPUrlMap) {
   BrowseInfo* browse_info = GetBrowseInfo();
 
   // Empty IP or host are skipped
   UpdateIPUrlMap("250.10.10.10", std::string());
   ASSERT_EQ(0U, browse_info->ips.size());
   UpdateIPUrlMap(std::string(), "http://google.com/a");
   ASSERT_EQ(0U, browse_info->ips.size());
@@ skipping 392 matching lines @@
   EXPECT_TRUE(Mock::VerifyAndClear(csd_host_.get()));
   EXPECT_TRUE(Mock::VerifyAndClear(ui_manager_.get()));
   EXPECT_EQ(url, resource.url);
   EXPECT_EQ(url, resource.original_url);
   resource.callback.Reset();
   msg = process()->sink().GetFirstMessageMatching(
       SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 }
 }  // namespace safe_browsing