Extensions: Move cast_channel and hid APIs to extensions/.

extensions/browser/api/cast_channel/cast_auth_util_nss.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/cast_channel/cast_auth_util.h"
+#include "extensions/browser/api/cast_channel/cast_auth_util.h"
 
 #include <cert.h>
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <seccomon.h>
 #include <string>
 
 #include "base/logging.h"
-#include "chrome/browser/extensions/api/cast_channel/cast_channel.pb.h"
-#include "chrome/browser/extensions/api/cast_channel/cast_message_util.h"
 #include "crypto/nss_util.h"
 #include "crypto/scoped_nss_types.h"
+#include "extensions/browser/api/cast_channel/cast_channel.pb.h"
+#include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "net/base/hash_value.h"
 #include "net/cert/x509_certificate.h"
 
+namespace extensions {
+namespace core_api {
+namespace cast_channel {
+
 namespace {
 
 // Fingerprints and public keys of the allowed / trusted ICAs.
 static const net::SHA1HashValue kFingerprintICA1 = { {
     0x57,0x16,0xE2,0xAD,0x73,0x2E,0xBE,0xDA,0xEB,0x18,
     0xE8,0x47,0x15,0xA8,0xDE,0x90,0x3B,0x5E,0x2A,0xF4
 } };
 static const unsigned char kPublicKeyICA1[] = {
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xBC,0x22,0x80,
     0xBD,0x80,0xF6,0x3A,0x21,0x00,0x3B,0xAE,0x76,0x5E,0x35,0x7F,
@@ skipping 145 matching lines @@
 // Returns -1, if no such ICA is found.
 static int GetICAWithFingerprint(const net::SHA1HashValue& fingerprint) {
   for (size_t i = 0; i < arraysize(kAllowedICAs); ++i) {
     if (kAllowedICAs[i].fingerprint->Equals(fingerprint))
       return static_cast<int>(i);
   }
   return -1;
 }
 
 // Parses out DeviceAuthMessage from CastMessage
-static bool ParseAuthMessage(
-    const extensions::api::cast_channel::CastMessage& challenge_reply,
-    extensions::api::cast_channel::DeviceAuthMessage* auth_message) {
-  if (challenge_reply.payload_type() !=
-      extensions::api::cast_channel::CastMessage_PayloadType_BINARY) {
+static bool ParseAuthMessage(const CastMessage& challenge_reply,
+                             DeviceAuthMessage* auth_message) {
+  if (challenge_reply.payload_type() != CastMessage_PayloadType_BINARY) {
     VLOG(1) << "Wrong payload type in challenge reply";
     return false;
   }
   if (!challenge_reply.has_payload_binary()) {
     VLOG(1) << "Payload type is binary but payload_binary field not set";
     return false;
   }
   if (!auth_message->ParseFromString(challenge_reply.payload_binary())) {
     VLOG(1) << "Cannot parse binary payload into DeviceAuthMessage";
     return false;
   }
   VLOG(1) << "Auth message: " << AuthMessageToString(*auth_message);
   if (auth_message->has_error()) {
     VLOG(1) << "Auth message error: " << auth_message->error().error_type();
     return false;
   }
   if (!auth_message->has_response()) {
     VLOG(1) << "Auth message has no response field";
     return false;
   }
   return true;
 }
 
 // Authenticates the given credentials:
 // 1. |signature| verification of |data| using |certificate|.
 // 2. |certificate| is signed by a trusted CA.
-bool VerifyCredentials(
-    const extensions::api::cast_channel::AuthResponse& response,
-    const std::string& data) {
+bool VerifyCredentials(const AuthResponse& response,
+                       const std::string& data) {
   const std::string& certificate = response.client_auth_certificate();
   const std::string& signature = response.signature();
 
   const SECItem* trusted_ca_key_der;
 
   // If the list of intermediates is empty then use kPublicKeyICA1 as
   // the trusted CA (legacy case).
   // Otherwise, use the first intermediate in the list as long as it
   // is in the allowed list of intermediates.
   int num_intermediates = response.intermediate_certificate_size();
@@ skipping 65 matching lines @@
   if (verified != SECSuccess) {
     VLOG(1) << "Signed blobs did not match.";
     return false;
   }
   VLOG(1) << "Signature verification succeeded";
   return true;
 }
 
 }  // namespace
 
-namespace extensions {
-namespace api {
-namespace cast_channel {
-
 bool AuthenticateChallengeReply(const CastMessage& challenge_reply,
                                 const std::string& peer_cert) {
   if (peer_cert.empty())
     return false;
 
   VLOG(1) << "Challenge reply: " << CastMessageToString(challenge_reply);
   DeviceAuthMessage auth_message;
   if (!ParseAuthMessage(challenge_reply, &auth_message))
     return false;
 
   const AuthResponse& response = auth_message.response();
   return VerifyCredentials(response, peer_cert);
 }
 
 }  // namespace cast_channel
-}  // namespace api
+}  // namespace core_api
 }  // namespace extensions