The comment in base64.h implies that base::Base64Encode() can return false, but

this cannot happen in practice. Fix the comment.

The implementation of Base64Encode() attempts to check for the return value
MODP_B64_ERROR as a failure, but modp_b64_encode() cannot return this
value. Remove the check.

Remove unneeded integer cast.

Change the return type to void.

BUG=323357
TEST=base_unittests, compile all
TBR=jochen@chromium.org,miket@chromium.org,joi@chromium.org,akalin@chromium.org,sergeyu@chromium.org

Review URL: https://codereview.chromium.org/86913002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@239759 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 17 insertions, 47 deletions

diff --git a/net/base/keygen_handler_win.cc b/net/base/keygen_handler_win.cc
index e1d432c..59d90e8 100644
--- a/net/base/keygen_handler_win.cc
+++ b/net/base/keygen_handler_win.cc
@@ -211,10 +211,7 @@ std::string KeygenHandler::GenKeyAndSignChallenge() {
     }
 
     std::string result;
-    if (!base::Base64Encode(spkac, &result)) {
-      LOG(ERROR) << "Keygen failed: Couldn't convert signed key into base64";
-      return std::string();
-    }
+    base::Base64Encode(spkac, &result);
 
     VLOG(1) << "Keygen succeeded";
     return result;
diff --git a/net/cert/x509_certificate.cc b/net/cert/x509_certificate.cc
index 862a202..a095fdf 100644
--- a/net/cert/x509_certificate.cc
+++ b/net/cert/x509_certificate.cc
@@ -665,8 +665,7 @@ bool X509Certificate::GetPEMEncodedFromDER(const std::string& der_encoded,
   if (der_encoded.empty())
     return false;
   std::string b64_encoded;
-  if (!base::Base64Encode(der_encoded, &b64_encoded) || b64_encoded.empty())
-    return false;
+  base::Base64Encode(der_encoded, &b64_encoded);
   *pem_encoded = "-----BEGIN CERTIFICATE-----\n";
 
   // Divide the Base-64 encoded data into 64-character chunks, as per
diff --git a/net/http/http_auth_gssapi_posix.cc b/net/http/http_auth_gssapi_posix.cc
index 4ea4bb9..41cbcdb 100644
--- a/net/http/http_auth_gssapi_posix.cc
+++ b/net/http/http_auth_gssapi_posix.cc
@@ -734,11 +734,7 @@ int HttpAuthGSSAPI::GenerateAuthToken(const AuthCredentials* credentials,
   std::string encode_input(static_cast<char*>(output_token.value),
                            output_token.length);
   std::string encode_output;
-  bool base64_rv = base::Base64Encode(encode_input, &encode_output);
-  if (!base64_rv) {
-    LOG(ERROR) << "Base64 encoding of auth token failed.";
-    return ERR_ENCODING_CONVERSION_FAILED;
-  }
+  base::Base64Encode(encode_input, &encode_output);
   *auth_token = scheme_ + " " + encode_output;
   return OK;
 }
diff --git a/net/http/http_auth_handler_basic.cc b/net/http/http_auth_handler_basic.cc
index af5f188..e445c93 100644
--- a/net/http/http_auth_handler_basic.cc
+++ b/net/http/http_auth_handler_basic.cc
@@ -91,13 +91,9 @@ int HttpAuthHandlerBasic::GenerateAuthTokenImpl(
   DCHECK(credentials);
   // TODO(eroman): is this the right encoding of username/password?
   std::string base64_username_password;
-  if (!base::Base64Encode(
-          UTF16ToUTF8(credentials->username()) + ":" +
-          UTF16ToUTF8(credentials->password()),
-          &base64_username_password)) {
-    LOG(ERROR) << "Unexpected problem Base64 encoding.";
-    return ERR_UNEXPECTED;
-  }
+  base::Base64Encode(UTF16ToUTF8(credentials->username()) + ":" +
+                         UTF16ToUTF8(credentials->password()),
+                     &base64_username_password);
   *auth_token = "Basic " + base64_username_password;
   return OK;
 }
diff --git a/net/http/http_auth_handler_ntlm.cc b/net/http/http_auth_handler_ntlm.cc
index c0387d8..922800c 100644
--- a/net/http/http_auth_handler_ntlm.cc
+++ b/net/http/http_auth_handler_ntlm.cc
@@ -89,13 +89,9 @@ int HttpAuthHandlerNTLM::GenerateAuthTokenImpl(
   // Base64 encode data in output buffer and prepend "NTLM ".
   std::string encode_input(static_cast<char*>(out_buf), out_buf_len);
   std::string encode_output;
-  bool base64_rv = base::Base64Encode(encode_input, &encode_output);
+  base::Base64Encode(encode_input, &encode_output);
   // OK, we are done with |out_buf|
   free(out_buf);
-  if (!base64_rv) {
-    LOG(ERROR) << "Unexpected problem Base64 encoding.";
-    return ERR_UNEXPECTED;
-  }
   *auth_token = std::string("NTLM ") + encode_output;
   return OK;
 #endif
diff --git a/net/http/http_auth_sspi_win.cc b/net/http/http_auth_sspi_win.cc
index 11d64dc..5718f9e 100644
--- a/net/http/http_auth_sspi_win.cc
+++ b/net/http/http_auth_sspi_win.cc
@@ -280,13 +280,9 @@ int HttpAuthSSPI::GenerateAuthToken(const AuthCredentials* credentials,
   // Base64 encode data in output buffer and prepend the scheme.
   std::string encode_input(static_cast<char*>(out_buf), out_buf_len);
   std::string encode_output;
-  bool base64_rv = base::Base64Encode(encode_input, &encode_output);
+  base::Base64Encode(encode_input, &encode_output);
   // OK, we are done with |out_buf|
   free(out_buf);
-  if (!base64_rv) {
-    LOG(ERROR) << "Base64 encoding of auth token failed.";
-    return ERR_ENCODING_CONVERSION_FAILED;
-  }
   *auth_token = scheme_ + " " + encode_output;
   return OK;
 }
diff --git a/net/test/spawned_test_server/base_test_server.cc b/net/test/spawned_test_server/base_test_server.cc
index 775341b..7ef2aba 100644
--- a/net/test/spawned_test_server/base_test_server.cc
+++ b/net/test/spawned_test_server/base_test_server.cc
@@ -226,10 +226,8 @@ bool BaseTestServer::GetFilePathWithReplacements(
     const std::string& new_text = it->second;
     std::string base64_old;
     std::string base64_new;
-    if (!base::Base64Encode(old_text, &base64_old))
-      return false;
-    if (!base::Base64Encode(new_text, &base64_new))
-      return false;
+    base::Base64Encode(old_text, &base64_old);
+    base::Base64Encode(new_text, &base64_new);
     if (first_query_parameter) {
       new_file_path += "?";
       first_query_parameter = false;
@@ -400,8 +398,7 @@ bool BaseTestServer::GenerateArguments(base::DictionaryValue* arguments) const {
     }
     if (!ssl_options_.signed_cert_timestamps.empty()) {
       std::string b64_scts;
-      if (!base::Base64Encode(ssl_options_.signed_cert_timestamps, &b64_scts))
-        return false;
+      base::Base64Encode(ssl_options_.signed_cert_timestamps, &b64_scts);
       arguments->SetString("signed-cert-timestamps", b64_scts);
     }
   }
diff --git a/net/third_party/mozilla_security_manager/nsKeygenHandler.cpp b/net/third_party/mozilla_security_manager/nsKeygenHandler.cpp
index 4cf47c4..f239cc1 100644
--- a/net/third_party/mozilla_security_manager/nsKeygenHandler.cpp
+++ b/net/third_party/mozilla_security_manager/nsKeygenHandler.cpp
@@ -215,13 +215,9 @@ std::string GenKeyAndSignChallenge(int key_size_in_bits,
   }
 
   // Convert the signed public key and challenge into base64/ascii.
-  if (!base::Base64Encode(std::string(reinterpret_cast<char*>(signedItem.data),
-                                      signedItem.len),
-                          &result_blob)) {
-    LOG(ERROR) << "Couldn't convert signed public key into base64";
-    isSuccess = false;
-    goto failure;
-  }
+  base::Base64Encode(
+      std::string(reinterpret_cast<char*>(signedItem.data), signedItem.len),
+      &result_blob);
 
  failure:
   if (!isSuccess) {
diff --git a/net/websockets/websocket_basic_handshake_stream.cc b/net/websockets/websocket_basic_handshake_stream.cc
index 1a8154b..8c0e42e 100644
--- a/net/websockets/websocket_basic_handshake_stream.cc
+++ b/net/websockets/websocket_basic_handshake_stream.cc
@@ -33,8 +33,7 @@ std::string GenerateHandshakeChallenge() {
   std::string raw_challenge(websockets::kRawChallengeLength, '\0');
   crypto::RandBytes(string_as_array(&raw_challenge), raw_challenge.length());
   std::string encoded_challenge;
-  bool encode_success = base::Base64Encode(raw_challenge, &encoded_challenge);
-  DCHECK(encode_success);
+  base::Base64Encode(raw_challenge, &encoded_challenge);
   return encoded_challenge;
 }
 
diff --git a/net/websockets/websocket_handshake_handler.cc b/net/websockets/websocket_handshake_handler.cc
index 641b196..787dde6 100644
--- a/net/websockets/websocket_handshake_handler.cc
+++ b/net/websockets/websocket_handshake_handler.cc
@@ -351,8 +351,7 @@ void ComputeSecWebSocketAccept(const std::string& key,
 
   std::string hash =
       base::SHA1HashString(key + websockets::kWebSocketGuid);
-  bool encode_success = base::Base64Encode(hash, accept);
-  DCHECK(encode_success);
+  base::Base64Encode(hash, accept);
 }
 
 bool WebSocketHandshakeResponseHandler::ParseResponseInfo(
@@ -405,8 +404,7 @@ bool WebSocketHandshakeResponseHandler::ParseResponseHeaderBlock(
   std::string hash =
       base::SHA1HashString(challenge + websockets::kWebSocketGuid);
   std::string websocket_accept;
-  bool encode_success = base::Base64Encode(hash, &websocket_accept);
-  DCHECK(encode_success);
+  base::Base64Encode(hash, &websocket_accept);
 
   std::string response_message = base::StringPrintf(
       "%s %s\r\n", websockets::kHttpProtocolVersion, status->second.c_str());