[webcrypto] Remove code conditional on !defined(WEBCRYPTO_HAS_KEY_ALGORITHM).

content/renderer/webcrypto/jwk.cc

 // Copyright 2014 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 <algorithm>
 #include <functional>
 #include <map>
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/platform_crypto.h"
 #include "content/renderer/webcrypto/shared_crypto.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
-#include "third_party/WebKit/public/platform/WebCrypto.h"  // TODO(eroman): delete
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
 typedef blink::WebCryptoAlgorithm (*AlgorithmCreationFunc)();
 
 class JwkAlgorithmInfo {
@@ skipping 106 matching lines @@
   static blink::WebCryptoAlgorithm BindAlgorithmId() {
     return func(algorithm_id);
   }
 
   JwkAlgorithmInfoMap alg_to_info_;
 };
 
 base::LazyInstance<JwkAlgorithmRegistry> jwk_alg_registry =
     LAZY_INSTANCE_INITIALIZER;
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
 bool ImportAlgorithmsConsistent(const blink::WebCryptoAlgorithm& alg1,
                                 const blink::WebCryptoAlgorithm& alg2) {
   DCHECK(!alg1.isNull());
   DCHECK(!alg2.isNull());
   if (alg1.id() != alg2.id())
     return false;
   if (alg1.paramsType() != alg2.paramsType())
     return false;
   switch (alg1.paramsType()) {
     case blink::WebCryptoAlgorithmParamsTypeNone:
       return true;
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams:
       return ImportAlgorithmsConsistent(alg1.rsaHashedImportParams()->hash(),
                                         alg2.rsaHashedImportParams()->hash());
     case blink::WebCryptoAlgorithmParamsTypeHmacImportParams:
       return ImportAlgorithmsConsistent(alg1.hmacImportParams()->hash(),
                                         alg2.hmacImportParams()->hash());
     default:
       return false;
   }
 }
-#else
-bool ImportAlgorithmsConsistent(const blink::WebCryptoAlgorithm& alg1,
-                                const blink::WebCryptoAlgorithm& alg2) {
-  DCHECK(!alg1.isNull());
-  DCHECK(!alg2.isNull());
-  if (alg1.id() != alg2.id())
-    return false;
-  switch (alg1.id()) {
-    case blink::WebCryptoAlgorithmIdHmac:
-    case blink::WebCryptoAlgorithmIdRsaOaep:
-    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
-      if (ImportAlgorithmsConsistent(GetInnerHashAlgorithm(alg1),
-                                     GetInnerHashAlgorithm(alg2))) {
-        return true;
-      }
-      break;
-    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
-    case blink::WebCryptoAlgorithmIdSha1:
-    case blink::WebCryptoAlgorithmIdSha224:
-    case blink::WebCryptoAlgorithmIdSha256:
-    case blink::WebCryptoAlgorithmIdSha384:
-    case blink::WebCryptoAlgorithmIdSha512:
-    case blink::WebCryptoAlgorithmIdAesCbc:
-    case blink::WebCryptoAlgorithmIdAesGcm:
-    case blink::WebCryptoAlgorithmIdAesCtr:
-      return true;
-    default:
-      NOTREACHED();  // Not a supported algorithm.
-      break;
-  }
-  return false;
-}
-#endif
 
 // Extracts the required string property with key |path| from |dict| and saves
 // the result to |*result|. If the property does not exist or is not a string,
 // returns an error.
 Status GetJwkString(base::DictionaryValue* dict,
                     const std::string& path,
                     std::string* result) {
   base::Value* value = NULL;
   if (!dict->Get(path, &value))
     return Status::ErrorJwkPropertyMissing(path);
@@ skipping 370 matching lines @@
   } else {
     return Status::ErrorJwkUnrecognizedKty();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content