Refactor SRI check in PendingScript::notifyFinished()

third_party/WebKit/Source/core/dom/PendingScript.cpp

 /*
  * Copyright (C) 2010 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 101 matching lines @@
   DCHECK(resource());
   if (m_client)
     m_client->pendingScriptFinished(this);
 }
 
 void PendingScript::markParserBlockingLoadStartTime() {
   DCHECK_EQ(m_parserBlockingLoadStartTime, 0.0);
   m_parserBlockingLoadStartTime = monotonicallyIncreasingTime();
 }
 
+// Returns true if SRI check passed.
+static bool checkScriptResourceIntegrity(Resource* resource, Element* element) {
+  DCHECK_EQ(resource->getType(), Resource::Script);
+  ScriptResource* scriptResource = toScriptResource(resource);
+  String integrityAttr = element->fastGetAttribute(HTMLNames::integrityAttr);
+
+  // It is possible to get back a script resource with integrity metadata
+  // for a request with an empty integrity attribute. In that case, the
+  // integrity check should be skipped, so this check ensures that the
+  // integrity attribute isn't empty in addition to checking if the
+  // resource has empty integrity metadata.
+  if (integrityAttr.isEmpty() || scriptResource->integrityMetadata().isEmpty())
+    return true;
+
+  switch (scriptResource->integrityDisposition()) {
+    case ResourceIntegrityDisposition::Passed:
+      return true;
+
+    case ResourceIntegrityDisposition::Failed:
+      // TODO(jww): This should probably also generate a console
+      // message identical to the one produced by
+      // CheckSubresourceIntegrity below. See https://crbug.com/585267.
+      return false;
+
+    case ResourceIntegrityDisposition::NotChecked: {
+      if (!resource->resourceBuffer())
+        return true;
+
+      bool passed = SubresourceIntegrity::CheckSubresourceIntegrity(
+          scriptResource->integrityMetadata(), *element,
+          resource->resourceBuffer()->data(),
+          resource->resourceBuffer()->size(), resource->url(), *resource);
+      scriptResource->setIntegrityDisposition(
+          passed ? ResourceIntegrityDisposition::Passed
+                 : ResourceIntegrityDisposition::Failed);
+      return passed;
+    }
+  }
+
+  NOTREACHED();
+  return true;
+}
+
 void PendingScript::notifyFinished(Resource* resource) {
   // The following SRI checks need to be here because, unfortunately, fetches
   // are not done purely according to the Fetch spec. In particular,
   // different requests for the same resource do not have different
   // responses; the memory cache can (and will) return the exact same
   // Resource object.
   //
   // For different requests, the same Resource object will be returned and
   // will not be associated with the particular request.  Therefore, when the
   // body of the response comes in, there's no way to validate the integrity
   // of the Resource object against a particular request (since there may be
   // several pending requests all tied to the identical object, and the
   // actual requests are not stored).
   //
   // In order to simulate the correct behavior, Blink explicitly does the SRI
   // checks here, when a PendingScript tied to a particular request is
   // finished (and in the case of a StyleSheet, at the point of execution),
   // while having proper Fetch checks in the fetch module for use in the
   // fetch JavaScript API. In a future world where the ResourceFetcher uses
   // the Fetch algorithm, this should be fixed by having separate Response
   // objects (perhaps attached to identical Resource objects) per request.
   //
   // See https://crbug.com/500701 for more information.
   CHECK(m_isForTesting || m_element);
-  if (m_element) {
-    DCHECK_EQ(resource->getType(), Resource::Script);
-    ScriptResource* scriptResource = toScriptResource(resource);
-    String integrityAttr =
-        m_element->fastGetAttribute(HTMLNames::integrityAttr);
-
-    // It is possible to get back a script resource with integrity metadata
-    // for a request with an empty integrity attribute. In that case, the
-    // integrity check should be skipped, so this check ensures that the
-    // integrity attribute isn't empty in addition to checking if the
-    // resource has empty integrity metadata.
-    if (!integrityAttr.isEmpty() &&
-        !scriptResource->integrityMetadata().isEmpty()) {
-      ResourceIntegrityDisposition disposition =
-          scriptResource->integrityDisposition();
-      if (disposition == ResourceIntegrityDisposition::Failed) {
-        // TODO(jww): This should probably also generate a console
-        // message identical to the one produced by
-        // CheckSubresourceIntegrity below. See https://crbug.com/585267.
-        m_integrityFailure = true;
-      } else if (disposition == ResourceIntegrityDisposition::NotChecked &&
-                 resource->resourceBuffer()) {
-        m_integrityFailure = !SubresourceIntegrity::CheckSubresourceIntegrity(
-            scriptResource->integrityMetadata(), *m_element,
-            resource->resourceBuffer()->data(),
-            resource->resourceBuffer()->size(), resource->url(), *resource);
-        scriptResource->setIntegrityDisposition(
-            m_integrityFailure ? ResourceIntegrityDisposition::Failed
-                               : ResourceIntegrityDisposition::Passed);
-      }
-    }
-  }
+  if (m_element)
+    m_integrityFailure = !checkScriptResourceIntegrity(resource, m_element);
 
   // If script streaming is in use, the client will be notified in
   // streamingFinished.
   if (m_streamer)
     m_streamer->notifyFinished(resource);
   else if (m_client)
     m_client->pendingScriptFinished(this);
 }
 
 void PendingScript::notifyAppendData(ScriptResource* resource) {
@@ skipping 46 matching lines @@
 }
 
 void PendingScript::onPurgeMemory() {
   if (!m_streamer)
     return;
   m_streamer->cancel();
   m_streamer = nullptr;
 }
 
 }  // namespace blink