Fix Resource Priorities and Scheduling (Blink Side)

Source/core/fetch/ResourceLoadPriorityOptimizer.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/fetch/ResourceLoadPriorityOptimizer.h"
+#include "core/frame/Settings.h"
 #include "core/layout/LayoutObject.h"
 #include "platform/TraceEvent.h"
 
 #include "wtf/Vector.h"
 
 namespace blink {
 
 ResourceLoadPriorityOptimizer* ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()
 {
     DEFINE_STATIC_LOCAL(ResourceLoadPriorityOptimizer, s_renderLoadOptimizer, ());
     return &s_renderLoadOptimizer;
 }
 
 ResourceLoadPriorityOptimizer::ResourceAndVisibility::ResourceAndVisibility(ImageResource* image, VisibilityStatus visibilityStatus, uint32_t screenArea)
     : imageResource(image)
     , status(visibilityStatus)
     , screenArea(screenArea)
 {
 }
 
 ResourceLoadPriorityOptimizer::ResourceAndVisibility::~ResourceAndVisibility()
 {
 }
 
 ResourceLoadPriorityOptimizer::ResourceLoadPriorityOptimizer()
+    : m_retrievedSettings(false)
+    , m_increaseFetchPriorities(false)
 {
 }
 
 ResourceLoadPriorityOptimizer::~ResourceLoadPriorityOptimizer()
 {
 }
 
 void ResourceLoadPriorityOptimizer::addLayoutObject(LayoutObject* layoutObject)
 {
+    if (!m_retrievedSettings) {
+        m_increaseFetchPriorities = layoutObject->document().settings()->fetchIncreasePriorities();
+        m_retrievedSettings = true;
+    }
     m_objects.add(layoutObject);
     layoutObject->setHasPendingResourceUpdate(true);
 }
 
 void ResourceLoadPriorityOptimizer::removeLayoutObject(LayoutObject* layoutObject)
 {
     if (!layoutObject->hasPendingResourceUpdate())
         return;
     m_objects.remove(layoutObject);
     layoutObject->setHasPendingResourceUpdate(false);
@@ skipping 14 matching lines @@
 
     updateImageResourcesWithLoadPriority();
 }
 
 void ResourceLoadPriorityOptimizer::updateImageResourcesWithLoadPriority()
 {
     for (const auto& resource : m_imageResources) {
         ResourceLoadPriority priority = resource.value->status == Visible ?
             ResourceLoadPriorityLow : ResourceLoadPriorityVeryLow;
 
+        ASSERT(m_retrievedSettings);

[Bryan McQuade, 2015/08/11 13:05:12]

I think this assert is important given that we depend on the value having been
read and set here, but are we sure this will never fire? can
updateImageResourcesWithLoadPriority ever get called without a prior call to
addLayoutObject?

[Pat Meenan, 2015/08/11 14:18:40]

I'm not sure the ASSERT is even needed.  updateImageResourcesWithLoadPriority is
private and is only called from the updateAllImageResourcePriorities function
above.  updateAllImageResourcePriorities starts with an empty list of image
resources and walks the layout objects to build the list of imageResources. 
It's impossible for there to be any elements in m_imageResources without
addLayoutObject having been called.

I actually removed the assert because of that but I'd be willing to put it back
in if you think it's necessary to protect against though someone would have to
radically change the logic for it to be needed.

+        if (m_increaseFetchPriorities) {
+            priority = resource.value->status == Visible ?
+                ResourceLoadPriorityHigh : ResourceLoadPriorityLow;
+        }
+
         if (priority != resource.value->imageResource->resourceRequest().priority()) {
             resource.value->imageResource->mutableResourceRequest().setPriority(priority, resource.value->screenArea);
             resource.value->imageResource->didChangePriority(priority, resource.value->screenArea);
         }
     }
     m_imageResources.clear();
 }
 
 void ResourceLoadPriorityOptimizer::notifyImageResourceVisibility(ImageResource* img, VisibilityStatus status, const LayoutRect& screenRect)
 {
     if (!img || img->isLoaded())
         return;
 
     int screenArea = 0;
     if (!screenRect.isEmpty() && status == Visible)
         screenArea += static_cast<uint32_t>(screenRect.width() * screenRect.height());
 
     ImageResourceMap::AddResult result = m_imageResources.add(img->identifier(), adoptPtr(new ResourceAndVisibility(img, status, screenArea)));
     if (!result.isNewEntry && status == Visible) {
         result.storedValue->value->status = Visible;
         result.storedValue->value->screenArea += screenArea;
     }
 }
 
 }