Move CUP to new component client_update_protocol

components/client_update_protocol/ecdsa.cc

 // Copyright 2016 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 "components/update_client/client_update_protocol_ecdsa.h"
+#include "components/client_update_protocol/ecdsa.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "crypto/random.h"
 #include "crypto/sha2.h"
 #include "crypto/signature_verifier.h"
 
-namespace update_client {
+namespace client_update_protocol {
 
 namespace {
 
 std::vector<uint8_t> SHA256HashStr(const base::StringPiece& str) {
   std::vector<uint8_t> result(crypto::kSHA256Length);
   crypto::SHA256HashString(str, &result.front(), result.size());
   return result;
 }
 
 std::vector<uint8_t> SHA256HashVec(const std::vector<uint8_t>& vec) {
@@ skipping 48 matching lines @@
   if (!base::HexStringToBytes(hash_hex.as_string(), request_hash_out))
     return false;
   if (request_hash_out->size() != crypto::kSHA256Length)
     return false;
 
   return true;
 }
 
 }  // namespace
 
-ClientUpdateProtocolEcdsa::ClientUpdateProtocolEcdsa(
-    int key_version,
-    const base::StringPiece& public_key)
+Ecdsa::Ecdsa(int key_version, const base::StringPiece& public_key)
     : pub_key_version_(key_version),
       public_key_(public_key.begin(), public_key.end()) {}
 
-ClientUpdateProtocolEcdsa::~ClientUpdateProtocolEcdsa() {}
+Ecdsa::~Ecdsa() {}
 
-scoped_ptr<ClientUpdateProtocolEcdsa> ClientUpdateProtocolEcdsa::Create(
-    int key_version,
-    const base::StringPiece& public_key) {
+scoped_ptr<Ecdsa> Ecdsa::Create(int key_version,
+                                const base::StringPiece& public_key) {
   DCHECK_GT(key_version, 0);
   DCHECK(!public_key.empty());
 
-  return make_scoped_ptr(
-      new ClientUpdateProtocolEcdsa(key_version, public_key));
+  return make_scoped_ptr(new Ecdsa(key_version, public_key));
 }
 
-void ClientUpdateProtocolEcdsa::SignRequest(
-    const base::StringPiece& request_body,
-    std::string* query_params) {
+void Ecdsa::SignRequest(const base::StringPiece& request_body,
+                        std::string* query_params) {
   DCHECK(!request_body.empty());
   DCHECK(query_params);
 
   // Generate a random nonce to use for freshness, build the cup2key query
   // string, and compute the SHA-256 hash of the request body. Set these
   // two pieces of data aside to use during ValidateResponse().
   uint32_t nonce = 0;
   crypto::RandBytes(&nonce, sizeof(nonce));
   request_query_cup2key_ = base::StringPrintf("%d:%u", pub_key_version_, nonce);
   request_hash_ = SHA256HashStr(request_body);
 
   // Return the query string for the user to send with the request.
   std::string request_hash_hex =
       base::HexEncode(&request_hash_.front(), request_hash_.size());
   request_hash_hex = base::ToLowerASCII(request_hash_hex);
 
   *query_params = base::StringPrintf("cup2key=%s&cup2hreq=%s",
                                      request_query_cup2key_.c_str(),
                                      request_hash_hex.c_str());
 }
 
-bool ClientUpdateProtocolEcdsa::ValidateResponse(
-    const base::StringPiece& response_body,
-    const base::StringPiece& server_etag) {
+bool Ecdsa::ValidateResponse(const base::StringPiece& response_body,
+                             const base::StringPiece& server_etag) {
   DCHECK(!request_hash_.empty());
   DCHECK(!request_query_cup2key_.empty());
 
   if (response_body.empty() || server_etag.empty())
     return false;
 
   // Break the ETag into its two components (the ECDSA signature, and the
   // hash of the request that the server observed) and decode to byte buffers.
   std::vector<uint8_t> signature;
   std::vector<uint8_t> observed_request_hash;
@@ skipping 41 matching lines @@
   // If the verification fails, that implies one of two outcomes:
   // * The signature was modified
   // * The buffer that the server signed does not match the buffer that the
   //   client assembled -- implying that either request body or response body
   //   was modified, or a different nonce value was used.
   verifier.VerifyUpdate(&signed_message_hash.front(),
                         static_cast<int>(signed_message_hash.size()));
   return verifier.VerifyFinal();
 }
 
-}  // namespace update_client
+}  // namespace client_update_protocol