Use struct AlternativeService in OnAltSvc() and OnSpdyAltSvc() methods.

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.
 
 #include "net/spdy/spdy_framer.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/third_party/valgrind/memcheck.h"
-#include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "third_party/zlib/zlib.h"
 
 using base::StringPiece;
 using std::string;
 using std::vector;
 
 namespace net {
@@ skipping 2025 matching lines @@
                          altsvc_scratch_.buffer_length);
   StringPiece origin;
   bool successful_read = reader.ReadStringPiece16(&origin);
   if (!successful_read) {
     set_error(SPDY_INVALID_CONTROL_FRAME);
     return 0;
   }
   StringPiece value(altsvc_scratch_.buffer.get() + reader.GetBytesConsumed(),
                     altsvc_scratch_.buffer_length - reader.GetBytesConsumed());
 
-  string protocol_id;
-  string host;
-  uint16 port;
-  uint32 max_age;
-  double p;
-  bool success = SpdyAltSvcWireFormat::ParseHeaderFieldValue(
-      value, &protocol_id, &host, &port, &max_age, &p);
-  if (!success || protocol_id.length() == 0) {
+  SpdyAltSvcWireFormat::AlternativeService altsvc;
+  bool success = SpdyAltSvcWireFormat::ParseHeaderFieldValue(value, &altsvc);
+  if (!success || altsvc.protocol_id.length() == 0) {
     set_error(SPDY_INVALID_CONTROL_FRAME);
     return 0;
   }
 
-  // TODO(bnc): Pass on |p|.
-  visitor_->OnAltSvc(current_frame_stream_id_, max_age, port, protocol_id, host,
-                     origin);
+  visitor_->OnAltSvc(current_frame_stream_id_, origin, altsvc);
   CHANGE_STATE(SPDY_AUTO_RESET);
   return len;
 }
 
 size_t SpdyFramer::ProcessDataFramePaddingLength(const char* data, size_t len) {
   DCHECK_EQ(SPDY_READ_DATA_FRAME_PADDING_LENGTH, state_);
   DCHECK_EQ(0u, remaining_padding_payload_length_);
   DCHECK_EQ(DATA, current_frame_type_);
 
   size_t original_len = len;
@@ skipping 685 matching lines @@
 
   builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializeAltSvc(const SpdyAltSvcIR& altsvc) {
   DCHECK_LT(SPDY3, protocol_version());
 
   size_t size = GetAltSvcMinimumSize();
   size += altsvc.origin().length();
-  // TODO(bnc): Add probability to SpdyAltSvcIR and pass it on.
-  string value = SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
-      altsvc.protocol_id(), altsvc.host(), altsvc.port(), altsvc.max_age(),
-      1.0);
+  string value =
+      SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc.altsvc());
   size += value.length();
 
   SpdyFrameBuilder builder(size, protocol_version());
   builder.BeginNewFrame(*this, ALTSVC, kNoFlags, altsvc.stream_id());
 
   builder.WriteUInt16(altsvc.origin().length());
   builder.WriteBytes(altsvc.origin().data(), altsvc.origin().length());
   builder.WriteBytes(value.data(), value.length());
   DCHECK_LT(GetAltSvcMinimumSize(), builder.length());
   return builder.take();
@@ skipping 421 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.name_value_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net