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())
+  if (cache_collector_->HasStarted()) {

[panayiotis, 2011/05/13 21:15:26]

drop the { here 

[kewang, 2011/05/16 07:11:51]

Done.

     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<std::vector<GURL> > redirects =
+      redirects_collector_->GetCollectedUrls();
+
+  for (uint i = 0; i < redirects.size(); ++i) {
+    AddRedirectUrlList(redirects[i]);
+  }
+
+  // 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));
+  LOG(INFO) << "url list size:" << urls.size();

[panayiotis, 2011/05/13 21:15:26]

let's drop the logging 

[kewang, 2011/05/16 07:11:51]

Done.

+  for (uint i = 0; i < urls.size()-1; ++i) {
+    AddUrl(urls[i], urls[i+1], "", NULL);

[panayiotis, 2011/05/13 21:15:26]

I wonder if we should specify a tagname for these redirects. Maybe "redir" ? 

[kewang, 2011/05/16 07:11:51]

Done.

+    LOG(INFO) << "--- adding...." << urls[i];
+  }
+}
+
 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);
 }