Querying the history service to get the redirect information for urls....

chrome/browser/safe_browsing/malware_details.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.
 //
 // Implementation of the MalwareDetails class.
 
 #include "chrome/browser/safe_browsing/malware_details.h"
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/malware_details_cache.h"
+#include "chrome/browser/safe_browsing/malware_details_history.h"
 #include "chrome/browser/safe_browsing/report.pb.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 45 matching lines @@
 
 // Create a MalwareDetails for the given tab. Runs in the UI thread.
 MalwareDetails::MalwareDetails(
     SafeBrowsingService* sb_service,
     TabContents* tab_contents,
     const SafeBrowsingService::UnsafeResource& resource)
     : TabContentsObserver(tab_contents),
       request_context_getter_(tab_contents->profile()->GetRequestContext()),
       sb_service_(sb_service),
       resource_(resource),
-      cache_collector_(new MalwareDetailsCacheCollector) {
+      cache_collector_(new MalwareDetailsCacheCollector),
+      redirects_collector_(new MalwareDetailsRedirectsCollector) {
   StartCollection();
 }
 
 MalwareDetails::~MalwareDetails() {
 }
 
 bool MalwareDetails::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MalwareDetails, message)
     IPC_MESSAGE_HANDLER(SafeBrowsingHostMsg_MalwareDOMDetails,
@@ skipping 127 matching lines @@
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this, &MalwareDetails::AddDOMDetails, params));
 }
 
 void MalwareDetails::AddDOMDetails(
     const std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "Nodes from the DOM: " << params.size();
 
+  // If we have already started getting redirects from history service,
+  // don't modify state, otherwise will invalidate the iterators.
+  if (redirects_collector_->HasStarted())
+    return;
+
   // If we have already started collecting data from the HTTP cache, don't
   // modify our state.
   if (cache_collector_->HasStarted())
     return;
 
   // Add the urls from the DOM to |resources_|.  The renderer could be
   // sending bogus messages, so limit the number of nodes we accept.
   for (uint32 i = 0; i < params.size() && i < kMaxDomNodes; ++i) {
     SafeBrowsingHostMsg_MalwareDOMDetails_Node node = params[i];
     DVLOG(1) << node.url << ", " << node.tag_name << ", " << node.parent;
     AddUrl(node.url, node.parent, node.tag_name, &(node.children));
   }
 }
 
 // Called from the SB Service on the IO thread, after the user has
 // closed the tab, or clicked proceed or goback.  Since the user needs
 // to take an action, we expect this to be called after
 // OnReceivedMalwareDOMDetails in most cases. If not, we don't include
 // the DOM data in our report.
 void MalwareDetails::FinishCollection() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  std::vector<GURL> urls;
+  for (safe_browsing::ResourceMap::const_iterator it = resources_.begin();
+       it != resources_.end(); it++) {
+    urls.push_back(GURL(it->first));
+  }
+  redirects_collector_->StartHistoryCollection(
+      urls, tab_contents(),
+      NewRunnableMethod(this, &MalwareDetails::OnRedirectionCollectionReady));
+}
+
+void MalwareDetails::OnRedirectionCollectionReady() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  std::vector<safe_browsing::RedirectChain>* redirects =
+      redirects_collector_->GetCollectedUrls();
+
+  for (std::vector<safe_browsing::RedirectChain>::const_iterator it
+      = redirects->begin(); it != redirects->end(); ++it)
+    AddRedirectUrlList(*it);
+
+  // Call the cache collector
   cache_collector_->StartCacheCollection(
       request_context_getter_,
       &resources_,
       &cache_result_,
       NewRunnableMethod(this, &MalwareDetails::OnCacheCollectionReady));
 }
 
+void MalwareDetails::AddRedirectUrlList(const std::vector<GURL>& urls) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  for (uint i = 0; i < urls.size()-1; ++i) {

[mattm, 2011/05/17 03:17:01]

size_t

[kewang, 2011/05/18 05:47:40]

Done.

+    AddUrl(urls[i], urls[i+1], "redir", NULL);

[mattm, 2011/05/17 03:17:01]

"redir" should be a const.  Also, other places just seem to use "" when
recording redirects.  Is "redir" intended to mean that it came from this history
checking step specifically or should the other cases use it too?  (be sure to
include a comment with the const about what it means)

Should it have some sort of special chars or something to avoid name collisions
with actual tags?

[panayiotis, 2011/05/17 17:19:48]

Actually I take it back, let's not add any tagname, we don't need any. Sorry
about that Ke 

On 2011/05/17 03:17:01, mattm wrote:

[kewang, 2011/05/18 05:47:40]

const added. We are using it for all the redir urls. Applied the tag to other
redir urls too. They are all redir urls, just exist in different places. History
service contains the redirects except the ones to the final malware ones. That's
why we have two different places to get redir.

[kewang, 2011/05/18 05:47:40]

Followed Pano's suggestion and removed it.

+    LOG(INFO) << "--- adding...." << urls[i];

[panayiotis, 2011/05/16 17:14:55]

drop the log infos ... 

[kewang, 2011/05/18 05:47:40]

Done.

+  }
+}
+
 void MalwareDetails::OnCacheCollectionReady() {
   DVLOG(1) << "OnCacheCollectionReady.";
   // Add all the urls in our |resources_| maps to the |report_| protocol buffer.
   for (safe_browsing::ResourceMap::const_iterator it = resources_.begin();
        it != resources_.end(); it++) {
     ClientMalwareReportRequest::Resource* pb_resource =
         report_->add_resources();
     pb_resource->CopyFrom(*(it->second));
   }
 
   report_->set_complete(cache_result_);
 
   // Send the report, using the SafeBrowsingService.
   std::string serialized;
   if (!report_->SerializeToString(&serialized)) {
     DLOG(ERROR) << "Unable to serialize the malware report.";
     return;
   }
 
   sb_service_->SendSerializedMalwareDetails(serialized);
 }