Add experimental code behind a flag for Content Size Policy

content/browser/loader/loader_io_thread_notifier.h

 // Copyright 2016 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 CONTENT_BROWSER_LOADER_LOADER_IO_THREAD_NOTIFIER
 #define CONTENT_BROWSER_LOADER_LOADER_IO_THREAD_NOTIFIER
 
 #include "base/macros.h"
+#include "content/browser/loader/global_routing_id.h"
+#include "content/public/browser/navigation_throttle.h"
 #include "content/public/browser/web_contents_observer.h"
 
 namespace content {
 
+class FrameTreeNode;
+class NavigationHandle;
 class RenderFrameHost;
 class WebContents;
 
 // This class is responsible for notifying the IO thread (specifically, the
 // ResourceDispatcherHostImpl) of frame events. It has an interace for callers
 // to use and also sends notifications on WebContentsObserver events. All
 // methods (static or class) will be called from the UI thread and post to the
 // IO thread.
 class LoaderIOThreadNotifier : public WebContentsObserver {
  public:
   explicit LoaderIOThreadNotifier(WebContents* web_contents);
   ~LoaderIOThreadNotifier() override;
 
-  // content::WebContentsObserver:
+  // WebContentsObserver:
+  void RenderFrameCreated(RenderFrameHost* render_frame_host) override;
   void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
 
+  static void UpdateGlobalDataAccounting(
+      std::unique_ptr<std::map<GlobalFrameRoutingId, int>> updates);
+
+  static NavigationThrottle* MaybeCreateThrottle(NavigationHandle* handle);
+  NavigationThrottle::ThrottleCheckResult WillProcessNavigationResponse(
+      NavigationHandle* handle);
+
  private:
+  struct FrameSize {
+    int content_left = 0;
+    int content_limit = 0;
+  };
+
+  // Returns the effective size limit of this FrameTreeNode by walking up the
+  // tree.
+  LoaderIOThreadNotifier::FrameSize* AddNewFrame(FrameTreeNode* node,
+                                                 int limit);
+  LoaderIOThreadNotifier::FrameSize* GetEffectiveLimit(FrameTreeNode* node);
+
+  static void NotifyFramesWentOverSizeLimits(
+      std::unique_ptr<std::set<GlobalFrameRoutingId>> frames);
+  static void NotifyFrameHasLimit(const GlobalFrameRoutingId& frame,
+                                  int limit);
+
+  void UpdateDataAccounting(
+      std::map<GlobalFrameRoutingId, int> updates);
+
+  // frame_tree_node_id -> FrameSize map.
+  std::map<int, FrameSize> frame_tree_node_sizes_;

[mmenke, 2016/08/05 17:16:27]

This really doesn't belong in something called "LoaderIOThreadNotifier".  It has
nothing to do with notifying the IOThread of anything.

We need to store stuff on the UI thread, though, and learn about new frames
there.  Maybe a new WebContentsObserver, instead, specifically for this
component?

Alternatively, could make a separate class, and have this one own it can call
into it.

[Charlie Harrison, 2016/08/08 14:04:39]

Fair point. I mainly stuffed this logic here because this was the class designed
to be glue between loader-related things on the UI/IO thread. I've added another
class: ContentSizeFrameCounter, that is another WebContentsObserver, and kept
this class as-is.

+
   DISALLOW_COPY_AND_ASSIGN(LoaderIOThreadNotifier);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_LOADER_IO_THREAD_NOTIFIER