Avoid unnecessary byte-swapping in blink's SerializedScriptValue.

third_party/WebKit/Source/bindings/modules/v8/V8BindingForModulesTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 111 matching lines @@
                              const String& keyPath,
                              int expected) {
   IDBKey* idbKey = checkKeyFromValueAndKeyPathInternal(isolate, value, keyPath);
   ASSERT_TRUE(idbKey);
   ASSERT_EQ(IDBKey::NumberType, idbKey->getType());
   ASSERT_TRUE(expected == idbKey->number());
 }
 
 // SerializedScriptValue header format offsets are inferred from the Blink and
 // V8 serialization code. The code below DCHECKs that
-constexpr static size_t kSSVHeaderBlinkVersionOffset = 0;
-constexpr static size_t kSSVHeaderBlinkVersionTagOffset = 1;
-constexpr static size_t kSSVHeaderV8VersionOffset = 2;
-constexpr static size_t kSSVHeaderV8VersionTagOffset = 3;
+constexpr static size_t kSSVHeaderBlinkVersionTagOffset = 0;
+constexpr static size_t kSSVHeaderBlinkVersionOffset = 1;
+constexpr static size_t kSSVHeaderV8VersionTagOffset = 2;
+constexpr static size_t kSSVHeaderV8VersionOffset = 3;
 
 // 13 is v8::internal::kLatestVersion in v8/src/value-serializer.cc at the
 // time when this test was written. Unlike Blink, V8 does not currently export
 // its serialization version, so this number might get stale.
 constexpr static unsigned char kV8LatestKnownVersion = 13;
 
 // Follows the same steps as the IndexedDB value serialization code.
 void serializeV8Value(v8::Local<v8::Value> value,
                       v8::Isolate* isolate,
                       Vector<char>* wireBytes) {
   NonThrowableExceptionState nonThrowableExceptionState;
 
   SerializedScriptValue::SerializeOptions options;
   RefPtr<SerializedScriptValue> serializedValue =
       SerializedScriptValue::serialize(isolate, value, options,
                                        nonThrowableExceptionState);
   serializedValue->toWireBytes(*wireBytes);
 
   // Sanity check that the serialization header has not changed, as the tests
   // that use this method rely on the header format.
   //
   // The cast from char* to unsigned char* is necessary to avoid VS2015 warning
   // C4309 (truncation of constant value). This happens because VersionTag is
   // 0xFF.
   const unsigned char* wireData =
       reinterpret_cast<unsigned char*>(wireBytes->data());
+  ASSERT_EQ(static_cast<unsigned char>(VersionTag),
+            wireData[kSSVHeaderBlinkVersionTagOffset]);
   ASSERT_EQ(
       static_cast<unsigned char>(SerializedScriptValue::wireFormatVersion),
       wireData[kSSVHeaderBlinkVersionOffset]);
+
   ASSERT_EQ(static_cast<unsigned char>(VersionTag),
-            wireData[kSSVHeaderBlinkVersionTagOffset]);
-
+            wireData[kSSVHeaderV8VersionTagOffset]);
   ASSERT_GE(static_cast<unsigned char>(kV8LatestKnownVersion),
             wireData[kSSVHeaderV8VersionOffset]);
-  ASSERT_EQ(static_cast<unsigned char>(VersionTag),
-            wireData[kSSVHeaderV8VersionTagOffset]);
 }
 
 PassRefPtr<IDBValue> createIDBValue(v8::Isolate* isolate,
                                     Vector<char>& wireBytes,
                                     double primaryKey,
                                     const WebString& keyPath) {
   WebData webData(SharedBuffer::adoptVector(wireBytes));
   Vector<WebBlobInfo> webBlobInfo;
   WebIDBKey webIdbKey = WebIDBKey::createNumber(primaryKey);
   WebIDBKeyPath webIdbKeyPath(keyPath);
@@ skipping 202 matching lines @@
 
   v8::Local<v8::Value> v8Value =
       deserializeIDBValue(isolate, scope.context()->Global(), idbValue.get());
   EXPECT_TRUE(!scope.getExceptionState().hadException());
   ASSERT_TRUE(v8Value->IsNumber());
   v8::Local<v8::Number> v8Number = v8Value.As<v8::Number>();
   EXPECT_EQ(v8Number->Value(), 42.0);
 }
 
 }  // namespace blink