Remove the origin field from the CREDENTIAL frame.

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
@@ skipping 1501 matching lines @@
   }
 }
 
 TEST_F(SpdyFramerTest, CreateCredential) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "CREDENTIAL frame";
     const unsigned char kFrameData[] = {
       0x80, 0x02, 0x00, 0x0A,
-      0x00, 0x00, 0x00, 0x3F,
-      0x00, 0x03, 0x00, 0x0A,
-      'g',  'o',  'o',  'g',
-      'l',  'e',  '.',  'c',
-      'o',  'm',  0x00, 0x00,
+      0x00, 0x00, 0x00, 0x33,
+      0x00, 0x03, 0x00, 0x00,
       0x00, 0x05, 'p',  'r',
       'o',  'o',  'f',  0x00,
       0x00, 0x00, 0x06, 'a',
       ' ',  'c',  'e',  'r',
       't',  0x00, 0x00, 0x00,
       0x0C, 'a',  'n',  'o',
       't',  'h',  'e',  'r',
       ' ',  'c',  'e',  'r',
       't',  0x00,  0x00, 0x00,
       0x0A, 'f',  'i',  'n',
       'a',  'l',  ' ',  'c',
       'e',  'r',  't',
     };
     SpdyCredential credential;
     credential.slot = 3;
-    credential.origin = "google.com";
     credential.proof = "proof";
     credential.certs.push_back("a cert");
     credential.certs.push_back("another cert");
     credential.certs.push_back("final cert");
     scoped_ptr<SpdyFrame> frame(framer.CreateCredentialFrame(credential));
     CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
   }
 }
 
 TEST_F(SpdyFramerTest, ParseCredentialFrame) {
   SpdyFramer framer;
 
   {
     unsigned char kFrameData[] = {
       0x80, 0x02, 0x00, 0x0A,
-      0x00, 0x00, 0x00, 0x3F,
-      0x00, 0x03, 0x00, 0x0A,
-      'g',  'o',  'o',  'g',
-      'l',  'e',  '.',  'c',
-      'o',  'm',  0x00, 0x00,
+      0x00, 0x00, 0x00, 0x33,
+      0x00, 0x03, 0x00, 0x00,
       0x00, 0x05, 'p',  'r',
       'o',  'o',  'f',  0x00,
       0x00, 0x00, 0x06, 'a',
       ' ',  'c',  'e',  'r',
       't',  0x00, 0x00, 0x00,
       0x0C, 'a',  'n',  'o',
       't',  'h',  'e',  'r',
       ' ',  'c',  'e',  'r',
       't',  0x00,  0x00, 0x00,
       0x0A, 'f',  'i',  'n',
       'a',  'l',  ' ',  'c',
       'e',  'r',  't',
     };
     SpdyCredentialControlFrame frame(reinterpret_cast<char*>(kFrameData),
                                      false);
     SpdyCredential credential;
     EXPECT_TRUE(SpdyFramer::ParseCredentialData(frame.payload(),
                                                 frame.length(),
                                                 &credential));
     EXPECT_EQ(3u, credential.slot);
-    EXPECT_EQ("google.com", credential.origin);
     EXPECT_EQ("proof", credential.proof);
     EXPECT_EQ("a cert", credential.certs.front());
     credential.certs.erase(credential.certs.begin());
     EXPECT_EQ("another cert", credential.certs.front());
     credential.certs.erase(credential.certs.begin());
     EXPECT_EQ("final cert", credential.certs.front());
     credential.certs.erase(credential.certs.begin());
     EXPECT_TRUE(credential.certs.empty());
   }
 }
@@ skipping 45 matching lines @@
     visitor.SimulateInFramer(
         reinterpret_cast<unsigned char*>(template_frame.get()->data()),
          template_frame.get()->length() + SpdyControlFrame::kHeaderSize);
     EXPECT_EQ(1, visitor.syn_frame_count_);
   }
 }
 
 TEST_F(SpdyFramerTest, ReadCredentialFrame) {
   SpdyCredential credential;
   credential.slot = 3;
-  credential.origin = "google.com";
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer;
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
       control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.credential_count_);
   EXPECT_EQ(control_frame->length(), visitor.credential_buffer_length_);
   EXPECT_EQ(credential.slot, visitor.credential_.slot);
-  EXPECT_EQ(credential.origin, visitor.credential_.origin);
   EXPECT_EQ(credential.proof, visitor.credential_.proof);
   EXPECT_EQ(credential.certs.size(), visitor.credential_.certs.size());
   for (size_t i = 0; i < credential.certs.size(); i++) {
     EXPECT_EQ(credential.certs[i], visitor.credential_.certs[i]);
   }
 }
 
-TEST_F(SpdyFramerTest, ReadCredentialFrameWithCorruptOrigin) {
-  SpdyCredential credential;
-  credential.slot = 3;
-  credential.origin = "google.com";
-  credential.proof = "proof";
-  credential.certs.push_back("a cert");
-  credential.certs.push_back("another cert");
-  credential.certs.push_back("final cert");
-  SpdyFramer framer;
-  scoped_ptr<SpdyFrame> control_frame(
-      framer.CreateCredentialFrame(credential));
-  EXPECT_TRUE(control_frame.get() != NULL);
-  TestSpdyVisitor visitor;
-  visitor.use_compression_ = false;
-  unsigned char* data =
-      reinterpret_cast<unsigned char*>(control_frame.get()->data());
-  // Origin length is past the end of the frame
-  data[SpdyControlFrame::kHeaderSize + 2] = 0xFF;
-  visitor.SimulateInFramer(
-      data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
-  EXPECT_EQ(1, visitor.error_count_);
-}
-
 TEST_F(SpdyFramerTest, ReadCredentialFrameWithCorruptProof) {
   SpdyCredential credential;
   credential.slot = 3;
-  credential.origin = "google.com";
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer;
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   unsigned char* data =
       reinterpret_cast<unsigned char*>(control_frame.get()->data());
-  size_t offset = SpdyControlFrame::kHeaderSize + 4 +
-      credential.origin.length();
+  size_t offset = SpdyControlFrame::kHeaderSize + 4;
   data[offset] = 0xFF;  // Proof length is past the end of the frame
   visitor.SimulateInFramer(
       data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_F(SpdyFramerTest, ReadCredentialFrameWithCorruptCertificate) {
   SpdyCredential credential;
   credential.slot = 3;
-  credential.origin = "google.com";
   credential.proof = "proof";
   credential.certs.push_back("a cert");
   credential.certs.push_back("another cert");
   credential.certs.push_back("final cert");
   SpdyFramer framer;
   scoped_ptr<SpdyFrame> control_frame(
       framer.CreateCredentialFrame(credential));
   EXPECT_TRUE(control_frame.get() != NULL);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   unsigned char* data =
       reinterpret_cast<unsigned char*>(control_frame.get()->data());
-  size_t offset = SpdyControlFrame::kHeaderSize + 4 +
-      credential.origin.length() + 4 + credential.proof.length();
+  size_t offset = SpdyControlFrame::kHeaderSize + credential.proof.length();
   data[offset] = 0xFF;  // Certificate length is past the end of the frame
   visitor.SimulateInFramer(
       data, control_frame.get()->length() + SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 TEST_F(SpdyFramerTest, ReadGarbage) {
   SpdyFramer framer;
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
@@ skipping 149 matching lines @@
 }
 
 std::string RandomString(int length) {
   std::string rv;
   for (int index = 0; index < length; index++)
     rv += static_cast<char>('a' + (rand() % 26));
   return rv;
 }
 
 }  // namespace