Small modifications to safebrowsing code to make it simpler to add the extension

chrome/browser/safe_browsing/database_manager.h

 // 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.
 //
 // The Safe Browsing service is responsible for downloading anti-phishing and
 // anti-malware tables and checking urls against them.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
 
 #include <deque>
+#include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
@@ skipping 18 matching lines @@
 class DownloadProtectionService;
 }
 
 // Construction needs to happen on the main thread.
 class SafeBrowsingDatabaseManager
     : public base::RefCountedThreadSafe<SafeBrowsingDatabaseManager>,
       public SafeBrowsingProtocolManagerDelegate {
  public:
   class Client;
 
-  // Bundle of SafeBrowsing state for one URL or hash prefix check.
+  // Bundle of SafeBrowsing state while performing a URL or hash prefix check.
   struct SafeBrowsingCheck {
-    SafeBrowsingCheck();
+    // |check_type| should correspond to the type of item that is being
+    // checked, either a URL or a binary hash/URL. We store this for two
+    // purposes: to know which of Client's methods to call when a result is
+    // known, and for logging purposes. It *isn't* used to predict the response
+    // list type, that is information that the server gives us.
+    SafeBrowsingCheck(const std::vector<GURL>& urls,
+                      const std::vector<SBFullHash>& full_hashes,
+                      Client* client,
+                      safe_browsing_util::ListType check_type);
     ~SafeBrowsingCheck();
 
-    // Either |urls| or |prefix| is used to lookup database.
+    // Either |urls| or |full_hashes| is used to lookup database. |*_results|
+    // are parallel vectors containing the results. They are initialized to
+    // contain SB_THREAT_TYPE_SAFE.
     std::vector<GURL> urls;
-    scoped_ptr<SBFullHash> full_hash;
+    std::vector<SBThreatType> url_results;
+    std::vector<SBFullHash> full_hashes;
+    std::vector<SBThreatType> full_hash_results;
 
     Client* client;
     bool need_get_hash;
     base::TimeTicks start;  // When check was sent to SB service.
-    SBThreatType threat_type;
-    bool is_download;  // If this check for download url or hash.
+    safe_browsing_util::ListType check_type;  // See comment in constructor.
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> full_hits;
 
     // Vends weak pointers for TimeoutCallback().  If the response is
     // received before the timeout fires, factory is destructed and
     // the timeout won't be fired.
     // TODO(lzheng): We should consider to use this time out check
     // for browsing too (instead of implementin in
     // safe_browsing_resource_handler.cc).
     scoped_ptr<base::WeakPtrFactory<
@@ skipping 107 matching lines @@
   friend class SafeBrowsingServerTest;
   friend class SafeBrowsingServiceTest;
   friend class SafeBrowsingServiceTestHelper;
 
   typedef std::set<SafeBrowsingCheck*> CurrentChecks;
   typedef std::vector<SafeBrowsingCheck*> GetHashRequestors;
   typedef base::hash_map<SBPrefix, GetHashRequestors> GetHashRequests;
 
   // Clients that we've queued up for checking later once the database is ready.
   struct QueuedCheck {
+    safe_browsing_util::ListType check_type;
     Client* client;
     GURL url;
     base::TimeTicks start;  // When check was queued.
   };
 
   // Called to stop operations on the io_thread. This may be called multiple
   // times during the life of the DatabaseManager. Should be called on IO
   // thread.
   void DoStopOnIOThread();
 
@@ skipping 87 matching lines @@
   // Calls the Client's callback on IO thread after CheckDownloadUrl finishes.
   void CheckDownloadUrlDone(SafeBrowsingCheck* check);
 
   // Calls the Client's callback on IO thread after CheckDownloadHash finishes.
   void CheckDownloadHashDone(SafeBrowsingCheck* check);
 
   // Helper function that calls safe browsing client and cleans up |checks_|.
   void SafeBrowsingCheckDone(SafeBrowsingCheck* check);
 
   // Helper function to set |check| with default values and start a safe
-  // browsing check with timeout of |timeout_ms|. |task| will be called upon
+  // browsing check with timeout of |timeout|. |task| will be called on
   // success, otherwise TimeoutCallback will be called.
-  void StartDownloadCheck(SafeBrowsingCheck* check,
-                          Client* client,
-                          const base::Closure& task,
-                          int64 timeout_ms);
+  void StartSafeBrowsingCheck(SafeBrowsingCheck* check,
+                              const base::Closure& task);
 
   // SafeBrowsingProtocolManageDelegate override
   virtual void ResetDatabase() OVERRIDE;
   virtual void UpdateStarted() OVERRIDE;
   virtual void UpdateFinished(bool success) OVERRIDE;
   virtual void GetChunks(GetChunksCallback callback) OVERRIDE;
   virtual void AddChunks(const std::string& list, SBChunkList* chunks,
                          AddChunksCallback callback) OVERRIDE;
   virtual void DeleteChunks(
       std::vector<SBChunkDelete>* delete_chunks) OVERRIDE;
@@ skipping 40 matching lines @@
   // When true, newly fetched chunks may not in the database yet since the
   // database is still updating.
   bool database_update_in_progress_;
 
   // Indicates if we're in the midst of trying to close the database.  If this
   // is true, nothing on the IO thread should access the database.
   bool closing_database_;
 
   std::deque<QueuedCheck> queued_checks_;
 
-  // When download url check takes this long, client's callback will be called
-  // without waiting for the result.
-  int64 download_urlcheck_timeout_ms_;
-
-  // Similar to |download_urlcheck_timeout_ms_|, but for download hash checks.
-  int64 download_hashcheck_timeout_ms_;
+  // Timeout to use for safe browsing checks.
+  base::TimeDelta check_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseManager);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_