Reland "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 2027 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 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()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
+      // 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));
+      }
     } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      if (memcmp(frame_data,
+                 kV3SIMDFrameData,
+                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
+        CompareCharArraysWithHexError(kDescription,
+                                      frame_data,
+                                      frame->size(),
+                                      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()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
+      // 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));
+      }
     } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      if (memcmp(frame_data,
+                 kV3SIMDFrameData,
+                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
+        CompareCharArraysWithHexError(kDescription,
+                                      frame_data,
+                                      frame->size(),
+                                      kV3FrameData,
+                                      arraysize(kV3FrameData));
+      }
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
@@ skipping 578 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()) {
-      CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
+      // 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));
+      }
     } else if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      if (memcmp(frame_data,
+                 kV3SIMDFrameData,
+                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
+        CompareCharArraysWithHexError(kDescription,
+                                      frame_data,
+                                      frame->size(),
+                                      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 2849 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