Fix "unreachable code" warnings (MSVC warning 4702) in content/.

content/child/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/json/json_writer.h"
 #include "base/lazy_instance.h"
@@ skipping 684 matching lines @@
         algorithm_info->IsInvalidKeyByteLength(jwk_k_value.size())) {
       return Status::ErrorJwkIncorrectKeyLength();
     }
 
     return ImportKey(blink::WebCryptoKeyFormatRaw,
                      CryptoData(jwk_k_value),
                      algorithm,
                      extractable,
                      usage_mask,
                      key);
-  } else if (jwk_kty_value == "RSA") {
+  }
+  if (jwk_kty_value == "RSA") {
     // An RSA public key must have an "n" (modulus) and an "e" (exponent) entry
     // in the JWK, while an RSA private key must have those, plus at least a "d"
     // (private exponent) entry.
     // See http://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-18,
     // section 6.3.
 
     // RSA private key import is not currently supported, so fail here if a "d"
     // entry is found.
     // TODO(padolph): Support RSA private key import.
     if (dict_value->HasKey("d"))
       return Status::ErrorJwkRsaPrivateKeyUnsupported();
 
     std::string jwk_n_value;
     status = GetJwkBytes(dict_value, "n", &jwk_n_value);
     if (status.IsError())
       return status;
     std::string jwk_e_value;
     status = GetJwkBytes(dict_value, "e", &jwk_e_value);
     if (status.IsError())
       return status;
 
     return platform::ImportRsaPublicKey(algorithm,
                                         extractable,
                                         usage_mask,
                                         CryptoData(jwk_n_value),
                                         CryptoData(jwk_e_value),
                                         key);
 
-  } else {
-    return Status::ErrorJwkUnrecognizedKty();
   }
 
-  return Status::Success();
+  return Status::ErrorJwkUnrecognizedKty();
 }
 
 Status ExportKeyJwk(const blink::WebCryptoKey& key,
                     blink::WebArrayBuffer* buffer) {
   base::DictionaryValue jwk_dict;
   Status status = Status::Error();
   blink::WebArrayBuffer exported_key;
 
   if (key.type() == blink::WebCryptoKeyTypeSecret) {
     status = ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key);
@@ skipping 14 matching lines @@
   std::string json;
   base::JSONWriter::Write(&jwk_dict, &json);
   *buffer = CreateArrayBuffer(reinterpret_cast<const uint8*>(json.data()),
                               json.size());
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content