Make SpdyHeaderBlock non-copyable.

net/tools/flip_server/spdy_interface_test.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 "net/tools/flip_server/spdy_interface.h"
 
 #include <list>
 #include <memory>
 
 #include "base/strings/string_piece.h"
@@ skipping 31 matching lines @@
   const char* data;
   size_t size;
   std::string string;
 };
 
 class SpdyFramerVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   virtual ~SpdyFramerVisitor() {}
   MOCK_METHOD1(OnError, void(SpdyFramer::SpdyError));
   MOCK_METHOD2(OnStreamError, void(SpdyStreamId, const std::string&));
-  MOCK_METHOD6(OnSynStream,
+  // SaveArg cannot be used on non-copyable types like SpdyHeaderBlock.
+  void OnSynStream(SpdyStreamId stream_id,
+                   SpdyStreamId associated_stream_id,
+                   SpdyPriority priority,
+                   bool fin,
+                   bool unidirectional,
+                   const SpdyHeaderBlock& headers) override {
+    actual_header_block_ = headers.Clone();
+    OnSynStreamMock(stream_id, associated_stream_id, priority, fin,
+                    unidirectional, headers);
+  }
+  MOCK_METHOD6(OnSynStreamMock,
                void(SpdyStreamId,
                     SpdyStreamId,
                     SpdyPriority,
                     bool,
                     bool,
                     const SpdyHeaderBlock&));
-  MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
-  MOCK_METHOD7(OnHeaders,
+  void OnSynReply(SpdyStreamId stream_id,
+                  bool fin,
+                  const SpdyHeaderBlock& headers) override {
+    actual_header_block_ = headers.Clone();
+    OnSynReplyMock(stream_id, fin, headers);
+  }
+  MOCK_METHOD3(OnSynReplyMock,
+               void(SpdyStreamId, bool, const SpdyHeaderBlock&));
+  void OnHeaders(SpdyStreamId stream_id,
+                 bool has_priority,
+                 int weight,
+                 SpdyStreamId parent_stream_id,
+                 bool exclusive,
+                 bool fin,
+                 const SpdyHeaderBlock& headers) override {
+    actual_header_block_ = headers.Clone();
+    OnHeadersMock(stream_id, has_priority, weight, parent_stream_id, exclusive,
+                  fin, headers);
+  }
+  MOCK_METHOD7(OnHeadersMock,
                void(SpdyStreamId stream_id,
                     bool has_priority,
                     int weight,
                     SpdyStreamId parent_stream_id,
                     bool exclusive,
                     bool fin,
                     const SpdyHeaderBlock& headers));
   MOCK_METHOD3(OnDataFrameHeader, void(SpdyStreamId, size_t, bool));
   MOCK_METHOD3(OnStreamFrameData, void(SpdyStreamId, const char*, size_t));
   MOCK_METHOD1(OnStreamEnd, void(SpdyStreamId));
   MOCK_METHOD2(OnStreamPadding, void(SpdyStreamId, size_t));
   MOCK_METHOD1(OnHeaderFrameStart,
                SpdyHeadersHandlerInterface*(SpdyStreamId stream_id));
   MOCK_METHOD2(OnHeaderFrameEnd,
                void(SpdyStreamId stream_id, bool end_headers));
   MOCK_METHOD1(OnSettings, void(bool clear_persisted));
   MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8_t, uint32_t));
   MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
   MOCK_METHOD2(OnRstStream, void(SpdyStreamId, SpdyRstStreamStatus));
   MOCK_METHOD3(OnGoAway, void(SpdyStreamId, SpdyGoAwayStatus, StringPiece));
   MOCK_METHOD2(OnWindowUpdate, void(SpdyStreamId, int));
   MOCK_METHOD3(OnPushPromise,
                void(SpdyStreamId, SpdyStreamId, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnAltSvc,
                void(SpdyStreamId,
                     base::StringPiece,
                     const SpdyAltSvcWireFormat::AlternativeServiceVector&));
   MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type));
+
+  SpdyHeaderBlock actual_header_block_;
 };
 
 class FakeSMConnection : public SMConnection {
  public:
   FakeSMConnection(EpollServer* epoll_server,
                    SSLState* ssl_state,
                    MemoryCache* memory_cache,
                    FlipAcceptor* acceptor,
                    std::string log_prefix)
       : SMConnection(epoll_server,
@@ skipping 260 matching lines @@
     memory_cache_->InsertFile(&headers, filename, "");
     mci.file_data = memory_cache_->GetFileData(filename);
   }
 
   interface_->AddToOutputOrder(mci);
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_P(SpdySMProxyTest, SendErrorNotFound) {
   uint32_t stream_id = 82;
-  SpdyHeaderBlock actual_header_block;
   const char* actual_data;
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->SendErrorNotFound(stream_id);
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
     if (GetParam() < HTTP2) {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnSynReply(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_, OnSynReplyMock(stream_id, false, _));
     } else {
       EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, /*has_priority=*/false, _, _, _,
-                            /*fin=*/false, _))
-          .WillOnce(SaveArg<6>(&actual_header_block));
+                  OnHeadersMock(stream_id, /*has_priority=*/false, _, _, _,
+                                /*fin=*/false, _));
     }
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_, OnStreamFrameData(stream_id, _, _))
         .Times(1)
         .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_, OnStreamFrameData(stream_id, NULL, 0))
         .Times(1);
   }
 
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   checkpoint.Call(0);
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
 
   ASSERT_EQ(2, spdy_framer_->frames_received());
-  ASSERT_EQ(2u, actual_header_block.size());
-  ASSERT_EQ("404 Not Found", actual_header_block[":status"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
+  ASSERT_EQ(2u, spdy_framer_visitor_->actual_header_block_.size());
+  ASSERT_EQ("404 Not Found",
+            spdy_framer_visitor_->actual_header_block_[":status"]);
+  ASSERT_EQ("HTTP/1.1", spdy_framer_visitor_->actual_header_block_[":version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 TEST_P(SpdySMProxyTest, SendSynStream) {
   uint32_t stream_id = 82;
   BalsaHeaders headers;
-  SpdyHeaderBlock actual_header_block;
   headers.AppendHeader("key1", "value1");
   headers.AppendHeader("Host", "www.example.com");
   headers.SetRequestFirstlineFromStringPieces("GET", "/path", "HTTP/1.1");
 
   interface_->SendSynStream(stream_id, headers);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
 
   {
     InSequence s;
     EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynStream(stream_id, 0, _, false, false, _))
-        .WillOnce(SaveArg<5>(&actual_header_block));
+                OnSynStreamMock(stream_id, 0, _, false, false, _));
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
-  ASSERT_EQ(5u, actual_header_block.size());
-  ASSERT_EQ("GET", actual_header_block[":method"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
-  ASSERT_EQ("/path", actual_header_block[":path"]);
-  ASSERT_EQ("www.example.com", actual_header_block[":host"]);
-  ASSERT_EQ("value1", actual_header_block["key1"]);
+  ASSERT_EQ(5u, spdy_framer_visitor_->actual_header_block_.size());
+  ASSERT_EQ("GET", spdy_framer_visitor_->actual_header_block_[":method"]);
+  ASSERT_EQ("HTTP/1.1", spdy_framer_visitor_->actual_header_block_[":version"]);
+  ASSERT_EQ("/path", spdy_framer_visitor_->actual_header_block_[":path"]);
+  ASSERT_EQ("www.example.com",
+            spdy_framer_visitor_->actual_header_block_[":host"]);
+  ASSERT_EQ("value1", spdy_framer_visitor_->actual_header_block_["key1"]);
 }
 
 TEST_P(SpdySMProxyTest, SendSynReply) {
   uint32_t stream_id = 82;
   BalsaHeaders headers;
-  SpdyHeaderBlock actual_header_block;
   headers.AppendHeader("key1", "value1");
   headers.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "OK");
 
   interface_->SendSynReply(stream_id, headers);
 
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
 
   {
     InSequence s;
     if (GetParam() < HTTP2) {
-      EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_, OnSynReplyMock(stream_id, false, _));
     } else {
       EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, /*has_priority=*/false, _, _, _,
-                            /*fin=*/false, _))
-          .WillOnce(SaveArg<6>(&actual_header_block));
+                  OnHeadersMock(stream_id, /*has_priority=*/false, _, _, _,
+                                /*fin=*/false, _));
     }
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
-  ASSERT_EQ(3u, actual_header_block.size());
-  ASSERT_EQ("200 OK", actual_header_block[":status"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
-  ASSERT_EQ("value1", actual_header_block["key1"]);
+  ASSERT_EQ(3u, spdy_framer_visitor_->actual_header_block_.size());
+  ASSERT_EQ("200 OK", spdy_framer_visitor_->actual_header_block_[":status"]);
+  ASSERT_EQ("HTTP/1.1", spdy_framer_visitor_->actual_header_block_[":version"]);
+  ASSERT_EQ("value1", spdy_framer_visitor_->actual_header_block_["key1"]);
 }
 
 TEST_P(SpdySMProxyTest, SendDataFrame) {
   uint32_t stream_id = 133;
   SpdyDataFlags flags = DATA_FLAG_NONE;
   const char* actual_data;
   size_t actual_size;
 
   interface_->SendDataFrame(stream_id, "hello", 5, flags, true);
 
@@ skipping 77 matching lines @@
     BalsaHeaders headers;
     memory_cache_->InsertFile(&headers, filename, "");
   }
 
   interface_->NewStream(stream_id, 0, filename);
   ASSERT_TRUE(HasStream(stream_id));
 }
 
 TEST_P(SpdySMServerTest, NewStreamError) {
   uint32_t stream_id = 82;
-  SpdyHeaderBlock actual_header_block;
   const char* actual_data;
   size_t actual_size;
   testing::MockFunction<void(int)> checkpoint;  // NOLINT
 
   interface_->NewStream(stream_id, 0, "nonexistingfile");
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
     if (GetParam() < HTTP2) {
-      EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_, OnSynReplyMock(stream_id, false, _));
     } else {
       EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, /*has_priority=*/false, _, _, _,
-                            /*fin=*/false, _))
-          .WillOnce(SaveArg<6>(&actual_header_block));
+                  OnHeadersMock(stream_id, /*has_priority=*/false, _, _, _,
+                                /*fin=*/false, _));
     }
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_, OnStreamFrameData(stream_id, _, _))
         .Times(1)
         .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_, OnStreamFrameData(stream_id, NULL, 0))
         .Times(1);
   }
 
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   checkpoint.Call(0);
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
 
   ASSERT_EQ(2, spdy_framer_->frames_received());
-  ASSERT_EQ(2u, actual_header_block.size());
-  ASSERT_EQ("404 Not Found", actual_header_block["status"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
+  ASSERT_EQ(2u, spdy_framer_visitor_->actual_header_block_.size());
+  ASSERT_EQ("404 Not Found",
+            spdy_framer_visitor_->actual_header_block_["status"]);
+  ASSERT_EQ("HTTP/1.1", spdy_framer_visitor_->actual_header_block_["version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 }  // namespace
 
 }  // namespace net