Move crypto files out of base, to a top level directory.

chrome/browser/safe_browsing/safe_browsing_database.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.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/time.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
-#include "base/sha2.h"
+#include "crypto/sha2.h"
 #include "chrome/browser/safe_browsing/bloom_filter.h"
 #include "chrome/browser/safe_browsing/prefix_set.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 #include "content/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 
 namespace {
 
 // Filename suffix for the bloom filter.
 const FilePath::CharType kBloomFilterFile[] = FILE_PATH_LITERAL(" Filter 2");
@@ skipping 37 matching lines @@
 }
 
 // Get the prefix for download url.
 void GetDownloadUrlPrefix(const GURL& url, SBPrefix* prefix) {
   std::string hostname;
   std::string path;
   std::string query;
   safe_browsing_util::CanonicalizeUrl(url, &hostname, &path, &query);
 
   SBFullHash full_hash;
-  base::SHA256HashString(hostname + path + query, &full_hash,
-                         sizeof(full_hash));
+  crypto::SHA256HashString(hostname + path + query, &full_hash,
+                           sizeof(full_hash));
   *prefix = full_hash.prefix;
 }
 
 // Generate the set of full hashes to check for |url|.  If
 // |include_whitelist_hashes| is true we will generate additional path-prefixes
 // to match against the csd whitelist.  E.g., if the path-prefix /foo is on the
 // whitelist it should also match /foo/bar which is not the case for all the
 // other lists.
 // TODO(shess): This function is almost the same as
 // |CompareFullHashes()| in safe_browsing_util.cc, except that code
@@ skipping 10 matching lines @@
     safe_browsing_util::GenerateHostsToCheck(url, &hosts);
   }
 
   std::vector<std::string> paths;
   safe_browsing_util::GeneratePathsToCheck(url, &paths);
 
   for (size_t i = 0; i < hosts.size(); ++i) {
     for (size_t j = 0; j < paths.size(); ++j) {
       const std::string& path = paths[j];
       SBFullHash full_hash;
-      base::SHA256HashString(hosts[i] + path, &full_hash,
-                             sizeof(full_hash));
+      crypto::SHA256HashString(hosts[i] + path, &full_hash,
+                               sizeof(full_hash));
       full_hashes->push_back(full_hash);
 
       // We may have /foo as path-prefix in the whitelist which should
       // also match with /foo/bar and /foo?bar.  Hence, for every path
       // that ends in '/' we also add the path without the slash.
       if (include_whitelist_hashes &&
           path.size() > 1 &&
           path[path.size() - 1] == '/') {
-        base::SHA256HashString(hosts[i] + path.substr(0, path.size() - 1),
-                               &full_hash, sizeof(full_hash));
+        crypto::SHA256HashString(hosts[i] + path.substr(0, path.size() - 1),
+                                 &full_hash, sizeof(full_hash));
         full_hashes->push_back(full_hash);
       }
     }
   }
 }
 
 // Find the entries in |full_hashes| with prefix in |prefix_hits|, and
 // add them to |full_hits| if not expired.  "Not expired" is when
 // either |last_update| was recent enough, or the item has been
 // received recently enough.  Expired items are not deleted because a
@@ skipping 1162 matching lines @@
   }
 
   std::vector<SBFullHash> new_csd_whitelist;
   for (std::vector<SBAddFullHash>::const_iterator it = full_hashes.begin();
        it != full_hashes.end(); ++it) {
     new_csd_whitelist.push_back(it->full_hash);
   }
   std::sort(new_csd_whitelist.begin(), new_csd_whitelist.end());
 
   SBFullHash kill_switch;
-  base::SHA256HashString(kCsdKillSwitchUrl, &kill_switch, sizeof(kill_switch));
+  crypto::SHA256HashString(kCsdKillSwitchUrl, &kill_switch,
+                           sizeof(kill_switch));
   if (std::binary_search(new_csd_whitelist.begin(), new_csd_whitelist.end(),
                          kill_switch)) {
     // The kill switch is whitelisted hence we whitelist all URLs.
     CsdWhitelistAllUrls();
   } else {
     base::AutoLock locked(lookup_lock_);
     csd_whitelist_all_urls_ = false;
     csd_whitelist_.swap(new_csd_whitelist);
   }
 }