Revert 150375 - Implement SHA-256 fingerprint support

chrome/browser/net/transport_security_persister.cc

 // 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.
 
 #include "chrome/browser/net/transport_security_persister.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "net/base/transport_security_state.h"
 #include "net/base/x509_certificate.h"
 
 using content::BrowserThread;
-using net::HashValue;
-using net::HashValueTag;
-using net::HashValueVector;
+using net::Fingerprint;
+using net::FingerprintVector;
 using net::TransportSecurityState;
 
 namespace {
 
-ListValue* SPKIHashesToListValue(const HashValueVector& hashes) {
+ListValue* SPKIHashesToListValue(const FingerprintVector& hashes) {
   ListValue* pins = new ListValue;
 
-  for (HashValueVector::const_iterator i = hashes.begin();
+  for (FingerprintVector::const_iterator i = hashes.begin();
        i != hashes.end(); ++i) {
-    std::string label;
-    switch (i->tag) {
-      case net::HASH_VALUE_SHA1:
-        label = "sha1/";
-        break;
-      case net::HASH_VALUE_SHA256:
-        label = "sha256/";
-        break;
-      default:
-        LOG(WARNING) << "Skipping invalid fingerprint with unknown type "
-                     << i->tag;
-        continue;
-    }
-
-    std::string hash_str(reinterpret_cast<const char*>(i->data()), i->size());
+    std::string hash_str(reinterpret_cast<const char*>(i->data),
+                         sizeof(i->data));
     std::string b64;
     base::Base64Encode(hash_str, &b64);
-    pins->Append(new StringValue(label + b64));
+    pins->Append(new StringValue("sha1/" + b64));
   }
 
   return pins;
 }
 
-void SPKIHashesFromListValue(const ListValue& pins, HashValueVector* hashes) {
+void SPKIHashesFromListValue(const ListValue& pins, FingerprintVector* hashes) {
   size_t num_pins = pins.GetSize();
   for (size_t i = 0; i < num_pins; ++i) {
     std::string type_and_base64;
-    HashValue fingerprint;
+    Fingerprint fingerprint;
     if (pins.GetString(i, &type_and_base64) &&
         TransportSecurityState::ParsePin(type_and_base64, &fingerprint)) {
       hashes->push_back(fingerprint);
     }
   }
 }
 
 // This function converts the binary hashes to a base64 string which we can
 // include in a JSON file.
 std::string HashedDomainToExternalString(const std::string& hashed) {
@@ skipping 270 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   bool dirty = false;
   if (!LoadEntries(state, &dirty)) {
     LOG(ERROR) << "Failed to deserialize state: " << state;
     return;
   }
   if (dirty)
     StateIsDirty(transport_security_state_);
 }