Make PacketReader/PacketWriter interfaces async-only.

blimp/net/test_common.h

 // Copyright 2015 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.
 
 #ifndef BLIMP_NET_TEST_COMMON_H_
 #define BLIMP_NET_TEST_COMMON_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 17 matching lines @@
 // Using this matcher for inequality checks will result in undefined behavior,
 // due to IOBuffer's lack of a size field.
 //
 // arg (type: IOBuffer*) The buffer to check.
 // data (type: std::string) The string to compare with |arg|.
 MATCHER_P(BufferEquals, expected, "") {
   return expected == std::string(arg->data(), expected.size());
 }
 
 // Checks if two proto messages are the same.
-// TODO(kmarshall): promote to a shared testing library.
 MATCHER_P(EqualsProto, message, "") {
   std::string expected_serialized;
   std::string actual_serialized;
   message.SerializeToString(&expected_serialized);
   arg.SerializeToString(&actual_serialized);
   return expected_serialized == actual_serialized;
 }
 
 // Checks if the contents of a buffer are an exact match with BlimpMessage.
 // arg (type: net::DrainableIOBuffer*) The buffer to check.
 // message (type: BlimpMessage) The message to compare with |arg|.
 MATCHER_P(BufferEqualsProto, message, "") {
   BlimpMessage actual_message;
-  actual_message.ParseFromArray(arg->data(), arg->BytesRemaining());
+  actual_message.ParseFromArray(arg->data(), message.ByteSize());
   std::string expected_serialized;
   std::string actual_serialized;
   message.SerializeToString(&expected_serialized);
   actual_message.SerializeToString(&actual_serialized);
   return expected_serialized == actual_serialized;
 }
 
 // GMock action that writes data from a string to an IOBuffer.
 //
 //   buf_idx (template parameter 0): 0-based index of the IOBuffer arg.
 //   str: the string containing data to be written to the IOBuffer.
 ACTION_TEMPLATE(FillBufferFromString,
                 HAS_1_TEMPLATE_PARAMS(int, buf_idx),
                 AND_1_VALUE_PARAMS(str)) {
   memcpy(testing::get<buf_idx>(args)->data(), str.data(), str.size());
 }
 
 // Returns true if |buf| has a prefix of |str|.
 // Behavior is undefined if len(buf) < len(str).
 bool BufferStartsWith(net::GrowableIOBuffer* buf, const std::string& str);
 
-// GMock action that writes data from a blimp message to an IOBuffer .
+// GMock action that writes data from a BlimpMessage to a GrowableIOBuffer.
+// Advances the buffer's |offset| to the end of the message.
 //
 //   buf_idx (template parameter 0): 0-based index of the IOBuffer arg.
 //   message: the blimp message containing data to be written to the IOBuffer
 ACTION_TEMPLATE(FillBufferFromMessage,
                 HAS_1_TEMPLATE_PARAMS(int, buf_idx),
                 AND_1_VALUE_PARAMS(message)) {
   message->SerializeToArray(testing::get<buf_idx>(args)->data(),
                             message->ByteSize());
+  testing::get<buf_idx>(args)->set_offset(message->ByteSize());
+}
+
+// Calls |set_offset()| for a GrowableIOBuffer.
+ACTION_TEMPLATE(SetBufferOffset,
+                HAS_1_TEMPLATE_PARAMS(int, buf_idx),
+                AND_1_VALUE_PARAMS(offset)) {
+  testing::get<buf_idx>(args)->set_offset(offset);
 }
 
 // Formats a string-based representation of a BlimpMessage header.
 std::string EncodeHeader(size_t size);
 
 class MockStreamSocket : public net::StreamSocket {
  public:
   MockStreamSocket();
   virtual ~MockStreamSocket();
 
@@ skipping 43 matching lines @@
   MOCK_METHOD1(HandleConnectionPtr, void(BlimpConnection* connection));
   void HandleConnection(scoped_ptr<BlimpConnection> connection) override;
 };
 
 class MockPacketReader : public PacketReader {
  public:
   MockPacketReader();
   ~MockPacketReader() override;
 
   MOCK_METHOD2(ReadPacket,
-               int(const scoped_refptr<net::GrowableIOBuffer>&,
-                   const net::CompletionCallback&));
+               void(const scoped_refptr<net::GrowableIOBuffer>&,
+                    const net::CompletionCallback&));
 };
 
 class MockPacketWriter : public PacketWriter {
  public:
   MockPacketWriter();
   ~MockPacketWriter() override;
 
   MOCK_METHOD2(WritePacket,
-               int(scoped_refptr<net::DrainableIOBuffer>,
-                   const net::CompletionCallback&));
+               void(scoped_refptr<net::DrainableIOBuffer>,
+                    const net::CompletionCallback&));
 };
 
 class MockConnectionErrorObserver : public ConnectionErrorObserver {
  public:
   MockConnectionErrorObserver();
   ~MockConnectionErrorObserver() override;
 
   MOCK_METHOD1(OnConnectionError, void(int error));
 };
 
 class MockBlimpMessageProcessor : public BlimpMessageProcessor {
  public:
   MockBlimpMessageProcessor();
 
   ~MockBlimpMessageProcessor() override;
 
   // Adapts calls from ProcessMessage to MockableProcessMessage by
   // unboxing the |message| scoped_ptr for GMock compatibility.
   void ProcessMessage(scoped_ptr<BlimpMessage> message,
                       const net::CompletionCallback& callback) override;
 
   MOCK_METHOD2(MockableProcessMessage,
                void(const BlimpMessage& message,
                     const net::CompletionCallback& callback));
 };
 
 }  // namespace blimp
 
 #endif  // BLIMP_NET_TEST_COMMON_H_