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

net/spdy/spdy_http_stream_spdy3_unittest.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_http_stream.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
@@ skipping 540 matching lines @@
       crypto::ECSignatureCreator::Create(private_key.get()));
   creator->Sign(secret, arraysize(secret), &proof_data);
   proof->assign(proof_data.begin(), proof_data.end());
 }
 
 }  // namespace
 
 // Constructs a standard SPDY SYN_STREAM frame for a GET request with
 // a credential set.
 SpdyFrame* ConstructCredentialRequestFrame(int slot, const GURL& url,
-                                                 int stream_id) {
+                                           int stream_id) {
   const SpdyHeaderInfo syn_headers = {
     SYN_STREAM,
     stream_id,
     0,
     ConvertRequestPriorityToSpdyPriority(LOWEST, 3),
     slot,
     CONTROL_FLAG_FIN,
     false,
     INVALID,
     NULL,
@@ skipping 156 matching lines @@
   callback.WaitForResult();
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream2->ReadResponseHeaders(
       callback.callback()));
   data.RunFor(1);
   EXPECT_EQ(OK, callback.WaitForResult());
   ASSERT_TRUE(response.headers.get() != NULL);
   ASSERT_EQ(200, response.headers->response_code());
 }
 
-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);
-};
-
-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);
-};
-
 TEST_F(SpdyHttpStreamSpdy3Test, SendCredentialsEC) {
-  scoped_ptr<crypto::ECSignatureCreatorFactory> ec_signature_creator_factory(
-      new MockECSignatureCreatorFactory());
-  crypto::ECSignatureCreator::SetFactoryForTesting(
-      ec_signature_creator_factory.get());
-
   scoped_refptr<base::SequencedWorkerPool> sequenced_worker_pool =
       new base::SequencedWorkerPool(1, "SpdyHttpStreamSpdy3Test");
   scoped_ptr<ServerBoundCertService> server_bound_cert_service(
       new ServerBoundCertService(new DefaultServerBoundCertStore(NULL),
                                  sequenced_worker_pool));
   std::string cert;
   std::string proof;
   GetECServerBoundCertAndProof("http://www.gmail.com/",
                                server_bound_cert_service.get(),
                                &cert, &proof);
 
   TestSendCredentials(server_bound_cert_service.get(), cert, proof);
 
   sequenced_worker_pool->Shutdown();
 }
 
 #endif  // !defined(USE_OPENSSL)
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace net