[Thread-safe] Take isolatedCopy() of SecurityOrigin in ResourceLoaderOptions

To prevent from sharing SecurityOrigin across threads, CrossThreadCopier
should take isolatedCopy() of SecurityOrigin in ResourceLoaderOptions.

BUG=415865

Review URL: https://codereview.chromium.org/583903003

git-svn-id: svn://svn.chromium.org/blink/trunk@183967 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/core.gypi

@@ -3584,6 +3584,7 @@
             'fetch/MemoryCacheTest.cpp',
             'fetch/RawResourceTest.cpp',
             'fetch/ResourceFetcherTest.cpp',
+            'fetch/ResourceLoaderOptionsTest.cpp',
             'fileapi/FileTest.cpp',
             'frame/ImageBitmapTest.cpp',
             'frame/SubresourceIntegrityTest.cpp',

third_party/WebKit/Source/core/fetch/ResourceLoaderOptions.h

@@ -158,7 +158,7 @@ struct CrossThreadResourceLoaderOptionsData {
         , mixedContentBlockingTreatment(options.mixedContentBlockingTreatment)
         , synchronousPolicy(options.synchronousPolicy)
         , corsEnabled(options.corsEnabled)
-        , securityOrigin(options.securityOrigin) { }
+        , securityOrigin(options.securityOrigin ? options.securityOrigin->isolatedCopy() : nullptr) { }
 
     operator ResourceLoaderOptions() const
     {

third_party/WebKit/Source/core/fetch/ResourceLoaderOptionsTest.cpp

+// Copyright 2014 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 ResourceLoaderOptionsTest_h
+#define ResourceLoaderOptionsTest_h
+
+#include "config.h"
+#include "core/fetch/ResourceLoaderOptions.h"
+
+#include "wtf/TypeTraits.h"
+
+#include <gtest/gtest.h>
+
+namespace blink {
+
+namespace {
+
+TEST(ResourceLoaderOptionsTest, DeepCopy)
+{
+    // Check that the fields of ResourceLoaderOptions are enums,
+    // except for initiatorInfo and securityOrigin.
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<DataBufferingPolicy>::value, DataBufferingPolicy_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<StoredCredentials>::value, StoredCredentials_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<CredentialRequest>::value, CredentialRequest_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<ContentSecurityPolicyCheck>::value, ContentSecurityPolicyCheck_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<RequestInitiatorContext>::value, RequestInitiatorContext_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<MixedContentBlockingTreatment>::value, MixedContentBlockingTreatment_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<SynchronousPolicy>::value, SynchronousPolicy_is_enum);
+    COMPILE_ASSERT(WTF::IsConvertibleToInteger<CORSEnabled>::value, CORSEnabled_is_enum);
+
+    ResourceLoaderOptions original;
+    RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString("http://www.google.com");
+    original.securityOrigin = securityOrigin;
+    original.initiatorInfo.name = AtomicString("xmlhttprequest");
+
+    CrossThreadResourceLoaderOptionsData copyData = CrossThreadCopier<ResourceLoaderOptions>::copy(original);
+    ResourceLoaderOptions copy = copyData;
+
+    // Check that contents are correctly copied to |copyData|
+    EXPECT_EQ(original.dataBufferingPolicy, copyData.dataBufferingPolicy);
+    EXPECT_EQ(original.allowCredentials, copyData.allowCredentials);
+    EXPECT_EQ(original.credentialsRequested, copyData.credentialsRequested);
+    EXPECT_EQ(original.contentSecurityPolicyOption, copyData.contentSecurityPolicyOption);
+    EXPECT_EQ(original.initiatorInfo.name, copyData.initiatorInfo.name);
+    EXPECT_EQ(original.initiatorInfo.position, copyData.initiatorInfo.position);
+    EXPECT_EQ(original.initiatorInfo.startTime, copyData.initiatorInfo.startTime);
+    EXPECT_EQ(original.requestInitiatorContext, copyData.requestInitiatorContext);
+    EXPECT_EQ(original.mixedContentBlockingTreatment, copyData.mixedContentBlockingTreatment);
+    EXPECT_EQ(original.synchronousPolicy, copyData.synchronousPolicy);
+    EXPECT_EQ(original.corsEnabled, copyData.corsEnabled);
+    EXPECT_EQ(original.securityOrigin->protocol(), copyData.securityOrigin->protocol());
+    EXPECT_EQ(original.securityOrigin->host(), copyData.securityOrigin->host());
+    EXPECT_EQ(original.securityOrigin->domain(), copyData.securityOrigin->domain());
+
+    // Check that pointers are different between |original| and |copyData|
+    EXPECT_NE(original.initiatorInfo.name.impl(), copyData.initiatorInfo.name.impl());
+    EXPECT_NE(original.securityOrigin.get(), copyData.securityOrigin.get());
+    EXPECT_NE(original.securityOrigin->protocol().impl(), copyData.securityOrigin->protocol().impl());
+    EXPECT_NE(original.securityOrigin->host().impl(), copyData.securityOrigin->host().impl());
+    EXPECT_NE(original.securityOrigin->domain().impl(), copyData.securityOrigin->domain().impl());
+
+    // Check that contents are correctly copied to |copy|
+    EXPECT_EQ(original.dataBufferingPolicy, copy.dataBufferingPolicy);
+    EXPECT_EQ(original.allowCredentials, copy.allowCredentials);
+    EXPECT_EQ(original.credentialsRequested, copy.credentialsRequested);
+    EXPECT_EQ(original.contentSecurityPolicyOption, copy.contentSecurityPolicyOption);
+    EXPECT_EQ(original.initiatorInfo.name, copy.initiatorInfo.name);
+    EXPECT_EQ(original.initiatorInfo.position, copy.initiatorInfo.position);
+    EXPECT_EQ(original.initiatorInfo.startTime, copy.initiatorInfo.startTime);
+    EXPECT_EQ(original.requestInitiatorContext, copy.requestInitiatorContext);
+    EXPECT_EQ(original.mixedContentBlockingTreatment, copy.mixedContentBlockingTreatment);
+    EXPECT_EQ(original.synchronousPolicy, copy.synchronousPolicy);
+    EXPECT_EQ(original.corsEnabled, copy.corsEnabled);
+    EXPECT_EQ(original.securityOrigin->protocol(), copy.securityOrigin->protocol());
+    EXPECT_EQ(original.securityOrigin->host(), copy.securityOrigin->host());
+    EXPECT_EQ(original.securityOrigin->domain(), copy.securityOrigin->domain());
+
+    // Check that pointers are different between |original| and |copy|
+    // FIXME: When |original| and |copy| are in different threads, then
+    // EXPECT_NE(original.initiatorInfo.name.impl(), copy.initiatorInfo.name.impl());
+    // should pass. However, in the unit test here, these two pointers are the
+    // same, because initiatorInfo.name is AtomicString.
+    EXPECT_NE(original.securityOrigin.get(), copy.securityOrigin.get());
+    EXPECT_NE(original.securityOrigin->protocol().impl(), copy.securityOrigin->protocol().impl());
+    EXPECT_NE(original.securityOrigin->host().impl(), copy.securityOrigin->host().impl());
+    EXPECT_NE(original.securityOrigin->domain().impl(), copy.securityOrigin->domain().impl());
+
+    // FIXME: The checks for content equality/pointer inequality for
+    // securityOrigin here is not complete (i.e. m_filePath is not checked).
+    // A unit test for SecurityOrigin::isolatedCopy() that covers these checks
+    // should be added.
+}
+
+} // namespace
+
+} // namespace blink
+
+#endif // ResourceLoaderOptionsTest_h

third_party/WebKit/Source/wtf/text/TextPosition.h

@@ -44,8 +44,8 @@ public:
     int zeroBasedInt() const { return m_zeroBasedValue; }
     int oneBasedInt() const { return m_zeroBasedValue + 1; }
 
-    bool operator==(OrdinalNumber other) { return m_zeroBasedValue == other.m_zeroBasedValue; }
-    bool operator!=(OrdinalNumber other) { return !((*this) == other); }
+    bool operator==(OrdinalNumber other) const { return m_zeroBasedValue == other.m_zeroBasedValue; }
+    bool operator!=(OrdinalNumber other) const { return !((*this) == other); }
 
     static OrdinalNumber first() { return OrdinalNumber(0); }
     static OrdinalNumber beforeFirst() { return OrdinalNumber(-1); }
@@ -66,8 +66,8 @@ public:
     {
     }
     TextPosition() { }
-    bool operator==(const TextPosition& other) { return m_line == other.m_line && m_column == other.m_column; }
-    bool operator!=(const TextPosition& other) { return !((*this) == other); }
+    bool operator==(const TextPosition& other) const { return m_line == other.m_line && m_column == other.m_column; }
+    bool operator!=(const TextPosition& other) const { return !((*this) == other); }
     WTF_EXPORT OrdinalNumber toOffset(const Vector<unsigned>&);
 
     // A 'minimum' value of position, used as a default value.