Simplify the EC signature creation code by moving it to a Helper.

net/spdy/spdy_test_util_spdy3.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 "net/spdy/spdy_test_util_spdy3.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "crypto/ec_private_key.h"
+#include "crypto/ec_signature_creator.h"
 #include "net/base/mock_cert_verifier.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 namespace test_spdy3 {
 
 namespace {
 
 // Parses a URL into the scheme, host, and path components required for a
 // SPDY request.
 void ParseUrl(const char* const url, std::string* scheme, std::string* host,
               std::string* path) {
   GURL gurl(url);
   path->assign(gurl.PathForRequest());
   scheme->assign(gurl.scheme());
   host->assign(gurl.host());
   if (gurl.has_port()) {
     host->append(":");
     host->append(gurl.port());
   }
 }
 
+// An ECSignatureCreator that returns deterministic signatures.
+class MockECSignatureCreator : public crypto::ECSignatureCreator {
+ public:
+  explicit MockECSignatureCreator(crypto::ECPrivateKey* key) : key_(key) {}
+
+  virtual bool Sign(const uint8* data,
+                    int data_len,
+                    std::vector<uint8>* signature) OVERRIDE {
+    std::vector<uint8> private_key_value;
+    key_->ExportValue(&private_key_value);
+    std::string head = "fakesignature";
+    std::string tail = "/fakesignature";
+
+    signature->clear();
+    signature->insert(signature->end(), head.begin(), head.end());
+    signature->insert(signature->end(), private_key_value.begin(),
+                      private_key_value.end());
+    signature->insert(signature->end(), '-');
+    signature->insert(signature->end(), data, data + data_len);
+    signature->insert(signature->end(), tail.begin(), tail.end());
+    return true;
+  }
+
+ private:
+  crypto::ECPrivateKey* key_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreator);
+};
+
+// An ECSignatureCreatorFactory creates MockECSignatureCreator.
+class MockECSignatureCreatorFactory : public crypto::ECSignatureCreatorFactory {
+ public:
+  MockECSignatureCreatorFactory() {}
+  virtual ~MockECSignatureCreatorFactory() {}
+
+  virtual crypto::ECSignatureCreator* Create(
+      crypto::ECPrivateKey* key) OVERRIDE {
+    return new MockECSignatureCreator(key);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreatorFactory);
+};
+
 }  // namespace
 
 // Chop a frame into an array of MockWrites.
 // |data| is the frame to chop.
 // |length| is the length of the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockWrite* ChopWriteFrame(const char* data, int length, int num_chunks) {
   MockWrite* chunks = new MockWrite[num_chunks];
   int chunk_size = length / num_chunks;
   for (int index = 0; index < num_chunks; index++) {
@@ skipping 938 matching lines @@
     CONTROL_FLAG_FIN,       // Control Flags
     false,                        // Compressed
     INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 
-SpdyTestStateHelper::SpdyTestStateHelper() {
+SpdyTestStateHelper::SpdyTestStateHelper()
+    : ec_signature_creator_factory_(new MockECSignatureCreatorFactory()) {
+  // Use the mock signature creator.
+  crypto::ECSignatureCreator::SetFactoryForTesting(
+      ec_signature_creator_factory_.get());
   // Pings can be non-deterministic, because they are sent via timer.
   SpdySession::set_enable_ping_based_connection_checking(false);
   // Avoid sending a non-default initial receive window size settings
   // frame on every test.
   SpdySession::set_default_initial_recv_window_size(
       kSpdyStreamInitialWindowSize);
   // Compression is per-session which makes it impossible to create
   // SPDY frames with static methods.
   BufferedSpdyFramer::set_enable_compression_default(false);
 }
 
 SpdyTestStateHelper::~SpdyTestStateHelper() {
   SpdySession::ResetStaticSettingsToInit();
   // TODO(rch): save/restore this value
   BufferedSpdyFramer::set_enable_compression_default(true);
+  crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
 }
 
 }  // namespace test_spdy3
 
 }  // namespace net