Implement crypto signature verification routines using OpenSSL.

extensions/browser/api/cast_channel/logger_unittest.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 <string>
 
 #include "base/test/simple_test_tick_clock.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/api/cast_channel/logger_util.h"
@@ skipping 91 matching lines @@
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   AuthResult auth_result = AuthResult::CreateWithParseError(
       "No response", AuthResult::ERROR_NO_RESPONSE);
 
   logger_->LogSocketChallengeReplyEvent(2, auth_result);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   auth_result =
       AuthResult::CreateWithNSSError("Parsing failed",
-                                     AuthResult::ERROR_NSS_CERT_PARSING_FAILED,
+                                     AuthResult::ERROR_CERT_PARSING_FAILED,
                                      kTestNssErrorCode);
   logger_->LogSocketChallengeReplyEvent(2, auth_result);
 
   LastErrors last_errors = logger_->GetLastErrors(2);
   EXPECT_EQ(last_errors.event_type, proto::AUTH_CHALLENGE_REPLY);
   EXPECT_EQ(last_errors.net_return_value, net::OK);
   EXPECT_EQ(last_errors.challenge_reply_error_type,
-            proto::CHALLENGE_REPLY_ERROR_NSS_CERT_PARSING_FAILED);
+            proto::CHALLENGE_REPLY_ERROR_CERT_PARSING_FAILED);
   EXPECT_EQ(last_errors.nss_error_code, kTestNssErrorCode);
 
   scoped_ptr<Log> log = GetLog();
   ASSERT_TRUE(log.get() != NULL);
 
   ASSERT_EQ(2, log->aggregated_socket_event_size());
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(0);
     EXPECT_EQ(1, aggregated_socket_event.id());
@@ skipping 39 matching lines @@
       EXPECT_EQ(5, event.timestamp_micros());
       EXPECT_EQ(proto::CHALLENGE_REPLY_ERROR_NO_RESPONSE,
                 event.challenge_reply_error_type());
       EXPECT_FALSE(event.has_net_return_value());
       EXPECT_FALSE(event.has_nss_error_code());
     }
     {
       const SocketEvent& event = aggregated_socket_event.socket_event(3);
       EXPECT_EQ(EventType::AUTH_CHALLENGE_REPLY, event.type());
       EXPECT_EQ(6, event.timestamp_micros());
-      EXPECT_EQ(proto::CHALLENGE_REPLY_ERROR_NSS_CERT_PARSING_FAILED,
+      EXPECT_EQ(proto::CHALLENGE_REPLY_ERROR_CERT_PARSING_FAILED,
                 event.challenge_reply_error_type());
       EXPECT_FALSE(event.has_net_return_value());
       EXPECT_EQ(kTestNssErrorCode, event.nss_error_code());
     }
   }
 }
 
 TEST_F(CastChannelLoggerTest, LogLastErrorEvents) {
   // Net return value is set to an error
   logger_->LogSocketEventWithRv(
@@ skipping 135 matching lines @@
 
   log = GetLog();
   ASSERT_TRUE(log.get() != NULL);
 
   EXPECT_EQ(0, log->aggregated_socket_event_size());
 }
 
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions