Revert of Integrate SIMD optimisations for zlib

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 2021 matching lines @@
   if (!IsSpdy2() && !IsSpdy3()) {
     // SYN_STREAM not supported for SPDY>3
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
 
   {
     const char kDescription[] =
         "SYN_STREAM frame, low pri, no FIN";
+
     const SpdyPriority priority = IsSpdy2() ? 2 : 4;
-
     const unsigned char kV2FrameData[] = {
       0x80, spdy_version_ch_, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x36,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x00,
       0x80, 0x00, 0x38, 0xea,
       0xdf, 0xa2, 0x51, 0xb2,
       0x62, 0x60, 0x62, 0x60,
       0x4e, 0x4a, 0x2c, 0x62,
       0x60, 0x06, 0x08, 0xa0,
@@ skipping 16 matching lines @@
       0xC2, 0x4B, 0x4A, 0x04,
       0xE5, 0x0B, 0x66, 0x80,
       0x00, 0x4A, 0xCB, 0xCF,
       0x07, 0x08, 0x20, 0x10,
       0x95, 0x96, 0x9F, 0x0F,
       0xA2, 0x00, 0x02, 0x28,
       0x29, 0xB1, 0x08, 0x20,
       0x80, 0x00, 0x00, 0x00,
       0x00, 0xFF, 0xFF,
     };
-    const unsigned char kV2SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x33,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      0x80, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x06,
-      0x13, 0x00, 0x01, 0x94,
-      0x94, 0x58, 0x04, 0x10,
-      0x40, 0x00, 0x00, 0x00,
-      0x00, 0xff, 0xff,
-    };
-    const unsigned char kV3SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x32,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x00, 0x00,
-      0x80, 0x00, 0x38, 0xea,
-      0xe3, 0xc6, 0xa7, 0xc2,
-      0x02, 0xe5, 0x0e, 0x50,
-      0xc2, 0x4b, 0x4a, 0x04,
-      0xe5, 0x0b, 0x66, 0x80,
-      0x00, 0x4a, 0xcb, 0xcf,
-      0x07, 0x08, 0x20, 0x24,
-      0x0a, 0x20, 0x80, 0x92,
-      0x12, 0x8b, 0x00, 0x02,
-      0x08, 0x00, 0x00, 0x00,
-      0xff, 0xff,
-    };
-
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(priority);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-    const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
     if (IsSpdy2()) {
-      // Try comparing with SIMD version, if that fails, do a failing check
-      // with pretty printing against non-SIMD version
-      if (memcmp(frame_data,
-                 kV2SIMDFrameData,
-                 std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV2FrameData,
-                                      arraysize(kV2FrameData));
-      }
+      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
-      }
+      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
   if (spdy_version_ > SPDY3) {
     // SYN_REPLY unsupported in SPDY>3
@@ skipping 168 matching lines @@
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x10, 0x95, 0x96,
       0x9f, 0x0f, 0xa2, 0x00,
       0x02, 0x28, 0x29, 0xb1,
       0x08, 0x20, 0x80, 0x00,
       0x00, 0x00, 0x00, 0xff,
       0xff,
     };
-    const unsigned char kV2SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x2f,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x06,
-      0x13, 0x00, 0x01, 0x94,
-      0x94, 0x58, 0x04, 0x10,
-      0x40, 0x00, 0x00, 0x00,
-      0x00, 0xff, 0xff,
-    };
-    const unsigned char kV3SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x02,
-      0x00, 0x00, 0x00, 0x2c,
-      0x00, 0x00, 0x00, 0x01,
-      0x38, 0xea, 0xe3, 0xc6,
-      0xa7, 0xc2, 0x02, 0xe5,
-      0x0e, 0x50, 0xc2, 0x4b,
-      0x4a, 0x04, 0xe5, 0x0b,
-      0x66, 0x80, 0x00, 0x4a,
-      0xcb, 0xcf, 0x07, 0x08,
-      0x20, 0x24, 0x0a, 0x20,
-      0x80, 0x92, 0x12, 0x8b,
-      0x00, 0x02, 0x08, 0x00,
-      0x00, 0x00, 0xff, 0xff,
-    };
-
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
-    const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
     if (IsSpdy2()) {
-      // Try comparing with SIMD version, if that fails, do a failing check
-      // with pretty printing against non-SIMD version
-      if (memcmp(frame_data,
-                 kV2SIMDFrameData,
-                 std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV2FrameData,
-                                      arraysize(kV2FrameData));
-      }
+      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
-      }
+      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
@@ skipping 549 matching lines @@
       0x4a, 0x04, 0xe5, 0x0b,
       0x66, 0x80, 0x00, 0x4a,
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x10, 0x95, 0x96,
       0x9f, 0x0f, 0xa2, 0x00,
       0x02, 0x28, 0x29, 0xb1,
       0x08, 0x20, 0x80, 0x00,
       0x00, 0x00, 0x00, 0xff,
       0xff,
     };
-    const unsigned char kV2SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x00, 0x00, 0x00, 0x2f,
-      0x00, 0x00, 0x00, 0x01,
-      0x00, 0x00, 0x38, 0xea,
-      0xdf, 0xa2, 0x51, 0xb2,
-      0x62, 0x60, 0x62, 0x60,
-      0x4e, 0x4a, 0x2c, 0x62,
-      0x60, 0x06, 0x08, 0xa0,
-      0xb4, 0xfc, 0x7c, 0x80,
-      0x00, 0x62, 0x60, 0x06,
-      0x13, 0x00, 0x01, 0x94,
-      0x94, 0x58, 0x04, 0x10,
-      0x40, 0x00, 0x00, 0x00,
-      0x00, 0xff, 0xff,
-    };
-    const unsigned char kV3SIMDFrameData[] = {
-      0x80, spdy_version_ch_, 0x00, 0x08,
-      0x00, 0x00, 0x00, 0x2c,
-      0x00, 0x00, 0x00, 0x01,
-      0x38, 0xea, 0xe3, 0xc6,
-      0xa7, 0xc2, 0x02, 0xe5,
-      0x0e, 0x50, 0xc2, 0x4b,
-      0x4a, 0x04, 0xe5, 0x0b,
-      0x66, 0x80, 0x00, 0x4a,
-      0xcb, 0xcf, 0x07, 0x08,
-      0x20, 0x24, 0x0a, 0x20,
-      0x80, 0x92, 0x12, 0x8b,
-      0x00, 0x02, 0x08, 0x00,
-      0x00, 0x00, 0xff, 0xff,
-    };
-
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
-    const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
     if (IsSpdy2()) {
-      // Try comparing with SIMD version, if that fails, do a failing check
-      // with pretty printing against non-SIMD version
-      if (memcmp(frame_data,
-                 kV2SIMDFrameData,
-                 std::min(arraysize(kV2SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV2FrameData,
-                                      arraysize(kV2FrameData));
-      }
+      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
     } else if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
-      }
+      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       // Deflate compression doesn't apply to HPACK.
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer(spdy_version_);
 
@@ skipping 2667 matching lines @@
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 }  // namespace net