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

net/base/transport_security_state.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 "net/base/transport_security_state.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/sha2.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "crypto/sha2.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/dns_util.h"
 
 namespace net {
 
 const long int TransportSecurityState::kMaxHSTSAgeSecs = 86400 * 365;  // 1 year
 
 TransportSecurityState::TransportSecurityState()
     : delegate_(NULL) {
 }
 
 void TransportSecurityState::EnableHost(const std::string& host,
                                         const DomainState& state) {
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return;
 
   bool temp;
   if (IsPreloadedSTS(canonicalized_host, &temp))
     return;
 
-  char hashed[base::SHA256_LENGTH];
-  base::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
+  char hashed[crypto::SHA256_LENGTH];
+  crypto::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
 
   // Use the original creation date if we already have this host.
   DomainState state_copy(state);
   DomainState existing_state;
   if (IsEnabledForHost(&existing_state, host))
     state_copy.created = existing_state.created;
 
   // We don't store these values.
   state_copy.preloaded = false;
   state_copy.domain.clear();
 
   enabled_hosts_[std::string(hashed, sizeof(hashed))] = state_copy;
   DirtyNotify();
 }
 
 bool TransportSecurityState::DeleteHost(const std::string& host) {
   const std::string canonicalized_host = CanonicalizeHost(host);
   if (canonicalized_host.empty())
     return false;
 
-  char hashed[base::SHA256_LENGTH];
-  base::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
+  char hashed[crypto::SHA256_LENGTH];
+  crypto::SHA256HashString(canonicalized_host, hashed, sizeof(hashed));
 
   std::map<std::string, DomainState>::iterator i = enabled_hosts_.find(
       std::string(hashed, sizeof(hashed)));
   if (i != enabled_hosts_.end()) {
     enabled_hosts_.erase(i);
     DirtyNotify();
     return true;
   }
   return false;
 }
@@ skipping 18 matching lines @@
     result->mode = DomainState::MODE_STRICT;
     result->include_subdomains = include_subdomains;
     result->preloaded = true;
     return true;
   }
 
   result->preloaded = false;
   base::Time current_time(base::Time::Now());
 
   for (size_t i = 0; canonicalized_host[i]; i += canonicalized_host[i] + 1) {
-    char hashed_domain[base::SHA256_LENGTH];
+    char hashed_domain[crypto::SHA256_LENGTH];
 
-    base::SHA256HashString(IncludeNUL(&canonicalized_host[i]), &hashed_domain,
-                           sizeof(hashed_domain));
+    crypto::SHA256HashString(IncludeNUL(&canonicalized_host[i]), &hashed_domain,
+                             sizeof(hashed_domain));
     std::map<std::string, DomainState>::iterator j =
         enabled_hosts_.find(std::string(hashed_domain, sizeof(hashed_domain)));
     if (j == enabled_hosts_.end())
       continue;
 
     if (current_time > j->second.expiry) {
       enabled_hosts_.erase(j);
       DirtyNotify();
       continue;
     }
@@ skipping 158 matching lines @@
   std::string out;
   CHECK(base::Base64Encode(hashed, &out));
   return out;
 }
 
 // This inverts |HashedDomainToExternalString|, above. It turns an external
 // string (from a JSON file) into an internal (binary) string.
 static std::string ExternalStringToHashedDomain(const std::string& external) {
   std::string out;
   if (!base::Base64Decode(external, &out) ||
-      out.size() != base::SHA256_LENGTH) {
+      out.size() != crypto::SHA256_LENGTH) {
     return std::string();
   }
 
   return out;
 }
 
 bool TransportSecurityState::Serialise(std::string* output) {
   DictionaryValue toplevel;
   for (std::map<std::string, DomainState>::const_iterator
        i = enabled_hosts_.begin(); i != enabled_hosts_.end(); ++i) {
@@ skipping 199 matching lines @@
         *include_subdomains = kPreloadedSTS[j].include_subdomains;
         return true;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace