Revert of Move more declarations from c/b/sb/sb_util.h to components.

chrome/browser/safe_browsing/local_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.
 //
 // Safe Browsing Database Manager implementation that manages a local
 // database.  This is used by Desktop Chromium.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
-#include "components/safe_browsing_db/util.h"
+#include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "url/gurl.h"
 
 class SafeBrowsingService;
 class SafeBrowsingDatabase;
 
 namespace net {
 class URLRequestContext;
 class URLRequestContextGetter;
 }
 
@@ skipping 12 matching lines @@
   // Bundle of SafeBrowsing state while performing a URL or hash prefix check.
   struct 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::ListType check_type,
+                      safe_browsing_util::ListType check_type,
                       const std::vector<SBThreatType>& expected_threats);
     ~SafeBrowsingCheck();
 
     // 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;
     std::vector<SBThreatType> url_results;
     std::vector<std::string> url_metadata;
     std::vector<SBFullHash> full_hashes;
     std::vector<SBThreatType> full_hash_results;
 
     SafeBrowsingDatabaseManager::Client* client;
     bool is_extended_reporting;
     bool need_get_hash;
     base::TimeTicks start;  // When check was sent to SB service.
-    safe_browsing::ListType check_type;  // See comment in constructor.
+    safe_browsing_util::ListType check_type;  // See comment in constructor.
     std::vector<SBThreatType> expected_threats;
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
 
     // Invoke one of client's callbacks with these results.
     void OnSafeBrowsingResult();
 
     // Vends weak pointers for async callbacks on the IO thread, such as
     // timeout checks and replies from checks performed on the SB task runner.
     // TODO(lzheng): We should consider to use this time out check
@@ skipping 59 matching lines @@
                            GetUrlSeverestThreatType);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            ServiceStopWithPendingChecks);
 
   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 {
-    QueuedCheck(const safe_browsing::ListType check_type,
+    QueuedCheck(const safe_browsing_util::ListType check_type,
                 Client* client,
                 const GURL& url,
                 const std::vector<SBThreatType>& expected_threats,
                 const base::TimeTicks& start);
     ~QueuedCheck();
-    safe_browsing::ListType check_type;
+    safe_browsing_util::ListType check_type;
     Client* client;
     GURL url;
     std::vector<SBThreatType> expected_threats;
     base::TimeTicks start;  // When check was queued.
   };
 
   // Return the threat type of the severest entry in |full_hashes| which matches
   // |hash|, or SAFE if none match.
   static SBThreatType GetHashSeverestThreatType(
       const SBFullHash& hash,
@@ skipping 182 matching lines @@
 
   std::deque<QueuedCheck> queued_checks_;
 
   // Timeout to use for safe browsing checks.
   base::TimeDelta check_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalSafeBrowsingDatabaseManager);
 };  // class LocalSafeBrowsingDatabaseManager
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_