Remove the origin field from the CREDENTIAL frame.

net/spdy/spdy_framer.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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 832 matching lines @@
 /* static */
 bool SpdyFramer::ParseCredentialData(const char* data, size_t len,
                                      SpdyCredential* credential) {
   DCHECK(credential);
 
   void* iter = NULL;
   SpdyFrameBuilder parser(data, len);
   if (!parser.ReadUInt16(&iter, &credential->slot))
     return false;
 
-  uint16 origin_len;
-  const char* origin_data;
-  if (!parser.ReadData(&iter, &origin_data, &origin_len))
-    return false;
-  credential->origin.assign(origin_data, origin_len);
-
   uint32 proof_len;
   const char* proof_data;
   if (!parser.ReadReadLen32PrefixedData(&iter, &proof_data, &proof_len))
     return false;
   credential->proof.assign(proof_data, proof_len);
 
   while (parser.IteratorHasRoomFor(iter, 1)) {
     uint32 cert_len;
     const char* cert_data;
     if (!parser.ReadReadLen32PrefixedData(&iter, &cert_data, &cert_len))
@@ skipping 192 matching lines @@
   frame.WriteUInt32(delta_window_size);
   return reinterpret_cast<SpdyWindowUpdateControlFrame*>(frame.take());
 }
 
 /* static */
 SpdyCredentialControlFrame* SpdyFramer::CreateCredentialFrame(
     const SpdyCredential& credential) {
   // Calculate the size of the frame by adding the size of the
   // variable length data to the size of the fixed length data.
   size_t frame_size =  SpdyCredentialControlFrame::size() +
-      credential.origin.length() + credential.proof.length();
-  DCHECK_EQ(SpdyCredentialControlFrame::size(), 16u);
+      credential.proof.length();
+  DCHECK_EQ(SpdyCredentialControlFrame::size(), 14u);
   for (vector<std::string>::const_iterator cert = credential.certs.begin();
        cert != credential.certs.end();
        cert++) {
     frame_size += sizeof(uint32);  // size of the cert_length field
     frame_size += cert->length();  // size of the cert_data field
   }
   size_t payload_size = frame_size - SpdyFrame::kHeaderSize;
 
   SpdyFrameBuilder frame(frame_size);
   // Create our FlagsAndLength.
   SpdyControlFlags flags = spdy::CONTROL_FLAG_NONE;
   FlagsAndLength flags_length = CreateFlagsAndLength(flags, payload_size);
 
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(CREDENTIAL);
   frame.WriteBytes(&flags_length, sizeof(flags_length));
   frame.WriteUInt16(credential.slot);
-  frame.WriteUInt16(credential.origin.size());
-  frame.WriteBytes(credential.origin.c_str(), credential.origin.size());
   frame.WriteUInt32(credential.proof.size());
   frame.WriteBytes(credential.proof.c_str(), credential.proof.size());
   for (vector<std::string>::const_iterator cert = credential.certs.begin();
        cert != credential.certs.end();
        cert++) {
     frame.WriteUInt32(cert->length());
     frame.WriteBytes(cert->c_str(), cert->length());
   }
   return reinterpret_cast<SpdyCredentialControlFrame*>(frame.take());
 }
@@ skipping 620 matching lines @@
 
 void SpdyFramer::set_enable_compression_default(bool value) {
   compression_default_ = value;
 }
 
 void SpdyFramer::set_validate_control_frame_sizes(bool value) {
   validate_control_frame_sizes_ = value;
 }
 
 }  // namespace spdy