Adds support for multiple malware/phishing resources in a page

chrome/browser/safe_browsing/safe_browsing_service.h

 // Copyright (c) 2006-2008 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.
 //
 // The Safe Browsing service is responsible for downloading anti-phishing and
 // anti-malware tables and checking urls against them.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_
 
@@ skipping 39 matching lines @@
     // Called when the result of checking a URL is known.
     virtual void OnUrlCheckResult(const GURL& url, UrlCheckResult result) = 0;
 
     // Called when the user has made a decision about how to handle the
     // SafeBrowsing interstitial page.
     virtual void OnBlockingPageComplete(bool proceed) = 0;
   };
 
   // Structure used to pass parameters between the IO and UI thread when
   // interacting with the blocking page.
-  struct BlockingPageParam {
+  struct UnsafeResource {
     GURL url;
-    bool proceed;
-    UrlCheckResult result;
+    ResourceType::Type resource_type;
+    UrlCheckResult threat_type;
     Client* client;
     int render_process_host_id;
     int render_view_id;
-    ResourceType::Type resource_type;
   };
 
   // Creates the safe browsing service.  Need to initialize before using.
   SafeBrowsingService();
   ~SafeBrowsingService();
 
   // Initializes the service.  io_loop is the message loop that the
   // caller of this service (ResourceDispatcherHost) wants to be notified on
   // for check results.  db_loop is the message loop for the thread to do
   // the database work.
@@ skipping 57 matching lines @@
       const std::vector<SBFullHashResult>& full_hashes,
       bool can_cache);
   void HandleChunk(const std::string& list, std::deque<SBChunk>* chunks);
   void HandleChunkDelete(std::vector<SBChunkDelete>* chunk_deletes);
 
   // Update management.
   void UpdateStarted();
   void UpdateFinished(bool update_succeeded);
 
   // The blocking page on the UI thread has completed.
-  void OnBlockingPageDone(const BlockingPageParam& param);
+  void OnBlockingPageDone(const std::vector<UnsafeResource>& resources,
+                          bool proceed);
 
   // Called when the SafeBrowsingProtocolManager has received updated MAC keys.
   void OnNewMacKeys(const std::string& client_key,
                     const std::string& wrapped_key);
 
   // Notification from the advanced options UI.
   void OnEnable(bool enabled);
   bool enabled() const { return enabled_; }
 
   // Called by the database (on the db thread) when a chunk insertion is
@@ skipping 79 matching lines @@
                               const std::vector<SBFullHashResult>& full_hashes);
 
   void HandleOneCheck(SafeBrowsingCheck* check,
                       const std::vector<SBFullHashResult>& full_hashes);
 
   // Runs on the database thread to inform the database we've resumed from a low
   // power state.
   void HandleResume();
 
   // Invoked on the UI thread to show the blocking page.
-  void DoDisplayBlockingPage(const BlockingPageParam& param);
+  void DoDisplayBlockingPage(const UnsafeResource& resource);
 
   // During a reset or the initial load we may have to queue checks until the
   // database is ready. This method is run once the database has loaded (or if
   // we shut down SafeBrowsing before the database has finished loading).
   void RunQueuedClients();
 
   void OnUpdateComplete(bool update_succeeded);
 
   MessageLoop* io_loop_;
 
@@ skipping 46 matching lines @@
     Client* client;
     GURL url;
     base::Time start;
   } QueuedCheck;
   std::deque<QueuedCheck> queued_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingService);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_SERVICE_H_