Clang format slam.

net/spdy/buffered_spdy_framer_unittest.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/buffered_spdy_framer.h"
 
 #include "net/spdy/spdy_test_util_common.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   explicit TestBufferedSpdyVisitor(SpdyMajorVersion spdy_version)
       : buffered_spdy_framer_(spdy_version, true),
         error_count_(0),
         setting_count_(0),
         syn_frame_count_(0),
         syn_reply_frame_count_(0),
         headers_frame_count_(0),
-        header_stream_id_(-1) {
-  }
+        header_stream_id_(-1) {}
 
   virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
-  virtual void OnStreamError(
-      SpdyStreamId stream_id,
-      const std::string& description) OVERRIDE {
-    LOG(INFO) << "SpdyFramer Error on stream: " << stream_id  << " "
+  virtual void OnStreamError(SpdyStreamId stream_id,
+                             const std::string& description) OVERRIDE {
+    LOG(INFO) << "SpdyFramer Error on stream: " << stream_id << " "
               << description;
     error_count_++;
   }
 
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional,
                            const SpdyHeaderBlock& headers) OVERRIDE {
@@ skipping 38 matching lines @@
 
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
                          uint32 value) OVERRIDE {
     setting_count_++;
   }
 
   virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
 
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE {
-  }
+                           SpdyRstStreamStatus status) OVERRIDE {}
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {
-  }
+                        SpdyGoAwayStatus status) OVERRIDE {}
 
   bool OnCredentialFrameData(const char*, size_t) {
     LOG(FATAL) << "Unexpected OnCredentialFrameData call.";
     return false;
   }
 
   void OnDataFrameHeader(const SpdyFrame* frame) {
     LOG(FATAL) << "Unexpected OnDataFrameHeader call.";
   }
 
@@ skipping 37 matching lines @@
 
   // Header block streaming state:
   SpdyStreamId header_stream_id_;
 
   // Headers from OnSyn, OnSynReply and OnHeaders for verification.
   SpdyHeaderBlock headers_;
 };
 
 }  // namespace
 
-class BufferedSpdyFramerTest
-    : public PlatformTest,
-      public ::testing::WithParamInterface<NextProto> {
+class BufferedSpdyFramerTest : public PlatformTest,
+                               public ::testing::WithParamInterface<NextProto> {
  protected:
   // Returns true if the two header blocks have equivalent content.
   bool CompareHeaderBlocks(const SpdyHeaderBlock* expected,
                            const SpdyHeaderBlock* actual) {
     if (expected->size() != actual->size()) {
       LOG(ERROR) << "Expected " << expected->size() << " headers; actually got "
                  << actual->size() << ".";
       return false;
     }
     for (SpdyHeaderBlock::const_iterator it = expected->begin();
@@ skipping 13 matching lines @@
       }
     }
     return true;
   }
 
   SpdyMajorVersion spdy_version() {
     return NextProtoToSpdyMajorVersion(GetParam());
   }
 };
 
-INSTANTIATE_TEST_CASE_P(
-    NextProto,
-    BufferedSpdyFramerTest,
-    testing::Values(kProtoDeprecatedSPDY2,
-                    kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
+INSTANTIATE_TEST_CASE_P(NextProto,
+                        BufferedSpdyFramerTest,
+                        testing::Values(kProtoDeprecatedSPDY2,
+                                        kProtoSPDY3,
+                                        kProtoSPDY31,
+                                        kProtoSPDY4));
 
 TEST_P(BufferedSpdyFramerTest, OnSetting) {
   SpdyFramer framer(spdy_version());
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, false, false, 2);
   settings_ir.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, false, false, 3);
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
   TestBufferedSpdyVisitor visitor(spdy_version());
 
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.setting_count_);
 }
 
 TEST_P(BufferedSpdyFramerTest, ReadSynStreamHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["aa"] = "vv";
   headers["bb"] = "ww";
   BufferedSpdyFramer framer(spdy_version(), true);
   scoped_ptr<SpdyFrame> control_frame(
-      framer.CreateSynStream(1,                        // stream_id
-                             0,                        // associated_stream_id
-                             1,                        // priority
+      framer.CreateSynStream(1,  // stream_id
+                             0,  // associated_stream_id
+                             1,  // priority
                              CONTROL_FLAG_NONE,
                              &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
   TestBufferedSpdyVisitor visitor(spdy_version());
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
       control_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(BufferedSpdyFramerTest, ReadSynReplyHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   BufferedSpdyFramer framer(spdy_version(), true);
-  scoped_ptr<SpdyFrame> control_frame(
-      framer.CreateSynReply(1,                        // stream_id
-                            CONTROL_FLAG_NONE,
-                            &headers));
+  scoped_ptr<SpdyFrame> control_frame(framer.CreateSynReply(1,  // stream_id
+                                                            CONTROL_FLAG_NONE,
+                                                            &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
   TestBufferedSpdyVisitor visitor(spdy_version());
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
       control_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
-  if(spdy_version() < SPDY4) {
+  if (spdy_version() < SPDY4) {
     EXPECT_EQ(1, visitor.syn_reply_frame_count_);
     EXPECT_EQ(0, visitor.headers_frame_count_);
   } else {
     EXPECT_EQ(0, visitor.syn_reply_frame_count_);
     EXPECT_EQ(1, visitor.headers_frame_count_);
   }
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 TEST_P(BufferedSpdyFramerTest, ReadHeadersHeaderBlock) {
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   headers["gamma"] = "delta";
   BufferedSpdyFramer framer(spdy_version(), true);
-  scoped_ptr<SpdyFrame> control_frame(
-      framer.CreateHeaders(1,                        // stream_id
-                           CONTROL_FLAG_NONE,
-                           &headers));
+  scoped_ptr<SpdyFrame> control_frame(framer.CreateHeaders(1,  // stream_id
+                                                           CONTROL_FLAG_NONE,
+                                                           &headers));
   EXPECT_TRUE(control_frame.get() != NULL);
 
   TestBufferedSpdyVisitor visitor(spdy_version());
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.get()->data()),
       control_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
 }
 
 }  // namespace net