Raise the loading priority of in-viewport images.

Source/core/fetch/ResourceLoadPriorityOptimizer.h

 /*
  * 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * 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.
  */
 
-#ifndef SubtreeLayoutScope_h
-#define SubtreeLayoutScope_h
+#ifndef ResourceLoadPriorityOptimizer_h
+#define ResourceLoadPriorityOptimizer_h
 
-#include "wtf/HashSet.h"
+#include "core/fetch/ImageResource.h"
+#include "core/fetch/ResourcePtr.h"
 
-// This is the way to mark a subtree as needing layout during layout,
-// e.g. for the purposes of doing a multipass layout.
-//
-// It should only be used during layout. Outside of layout, you should
-// just call renderer->setNeedsLayout() directly.
-//
-// It ensures that you don't accidentally mark part of the tree as
-// needing layout and not actually lay it out.
+#include "wtf/HashMap.h"
 
 namespace WebCore {
 
-class RenderObject;
-
-class SubtreeLayoutScope {
+class ResourceLoadPriorityOptimizer {
 public:
-    SubtreeLayoutScope(RenderObject* root);
-    ~SubtreeLayoutScope();
-
-    void setNeedsLayout(RenderObject* descendant);
-    void setChildNeedsLayout(RenderObject* descendant);
-
-    RenderObject* root() { return m_root; }
-    void addRendererToLayout(RenderObject* renderer);
+    enum VisibilityStatus {
+        NotVisible,
+        Visible,
+    };
+    ResourceLoadPriorityOptimizer();
+    ~ResourceLoadPriorityOptimizer();
+    void notifyImageResourceVisibility(ImageResource*, VisibilityStatus);
 
 private:
-    RenderObject* m_root;
+    void updateImageResourcesWithLoadPriority();
 
-#ifndef NDEBUG
-    HashSet<RenderObject*> m_renderersToLayout;
-#endif
+    struct ResourceAndVisibility {
+        ResourceAndVisibility(ImageResource*, VisibilityStatus);
+        ResourceAndVisibility();
+        ~ResourceAndVisibility();
+        ResourcePtr<ImageResource> imageResource;
+        VisibilityStatus status;
+    };
+
+    typedef WTF::HashMap<unsigned long, ResourceAndVisibility> ImageResourceMap;

[abarth-chromium, 2013/12/02 19:34:56]

Rather than using ResourceAndVisibility, you should store an
OwnPtr<ResourceAndVisibility>.  That has a couple benefits:

1) You don't need to write hash traits for ResourceAndVisibility because OwnPtr
already has them.
2) The table will use less memory.  HashMap stores the values inline, which
means the empty slots in the table are bloated by the size of the value.

Also, WTF::HashMap -> HashMap

[shatch, 2013/12/02 22:32:46]

Cool, thanks for the explanation! Done.

+    ImageResourceMap m_imageResources;
 };
 
 }
 
 #endif