Track frame openers in FrameTreeNodes instead of WebContents

content/browser/frame_host/frame_tree_node.cc

 // Copyright 2013 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.
 
 #include "content/browser/frame_host/frame_tree_node.h"
 
 #include <queue>
 
 #include "base/command_line.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 19 matching lines @@
 
 // These values indicate the loading progress status. The minimum progress
 // value matches what Blink's ProgressTracker has traditionally used for a
 // minimum progress value.
 const double kLoadingProgressNotStarted = 0.0;
 const double kLoadingProgressMinimum = 0.1;
 const double kLoadingProgressDone = 1.0;
 
 }  // namespace
 
+// This observer watches the opener of its owner FrameTreeNode and clears the
+// owner's opener if the opener is destroyed.
+class FrameTreeNode::OpenerDestroyedObserver : public FrameTreeNode::Observer {
+ public:
+  OpenerDestroyedObserver(FrameTreeNode* owner) : owner_(owner) {}
+
+  // FrameTreeNode::Observer
+  void OnFrameTreeNodeDestroyed(FrameTreeNode* node) override {
+    CHECK_EQ(owner_->opener(), node);
+    owner_->SetOpener(nullptr);
+  }
+
+ private:
+  FrameTreeNode* owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(OpenerDestroyedObserver);
+};
+
 int FrameTreeNode::next_frame_tree_node_id_ = 1;
 
 // static
 FrameTreeNode* FrameTreeNode::GloballyFindByID(int frame_tree_node_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FrameTreeNodeIDMap* nodes = g_frame_tree_node_id_map.Pointer();
   FrameTreeNodeIDMap::iterator it = nodes->find(frame_tree_node_id);
   return it == nodes->end() ? nullptr : it->second;
 }
 
 FrameTreeNode::FrameTreeNode(FrameTree* frame_tree,
                              Navigator* navigator,
                              RenderFrameHostDelegate* render_frame_delegate,
                              RenderViewHostDelegate* render_view_delegate,
                              RenderWidgetHostDelegate* render_widget_delegate,
                              RenderFrameHostManager::Delegate* manager_delegate,
                              blink::WebTreeScopeType scope,
                              const std::string& name,
                              blink::WebSandboxFlags sandbox_flags)
     : frame_tree_(frame_tree),
       navigator_(navigator),
       render_manager_(this,
                       render_frame_delegate,
                       render_view_delegate,
                       render_widget_delegate,
                       manager_delegate),
       frame_tree_node_id_(next_frame_tree_node_id_++),
       parent_(NULL),
+      opener_(nullptr),
+      opener_observer_(nullptr),
       replication_state_(scope, name, sandbox_flags),
       // Effective sandbox flags also need to be set, since initial sandbox
       // flags should apply to the initial empty document in the frame.
       effective_sandbox_flags_(sandbox_flags),
       loading_progress_(kLoadingProgressNotStarted) {
   std::pair<FrameTreeNodeIDMap::iterator, bool> result =
       g_frame_tree_node_id_map.Get().insert(
           std::make_pair(frame_tree_node_id_, this));
   CHECK(result.second);
 }
 
 FrameTreeNode::~FrameTreeNode() {
   frame_tree_->FrameRemoved(this);
+  FOR_EACH_OBSERVER(Observer, observers_, OnFrameTreeNodeDestroyed(this));
+
+  if (opener_)
+    opener_->RemoveObserver(opener_observer_.get());
 
   g_frame_tree_node_id_map.Get().erase(frame_tree_node_id_);
 }
 
+void FrameTreeNode::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void FrameTreeNode::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 bool FrameTreeNode::IsMainFrame() const {
   return frame_tree_->root() == this;
 }
 
 void FrameTreeNode::AddChild(scoped_ptr<FrameTreeNode> child,
                              int process_id,
                              int frame_routing_id) {
   // Child frame must always be created in the same process as the parent.
   CHECK_EQ(process_id, render_manager_.current_host()->GetProcess()->GetID());
 
@@ skipping 37 matching lines @@
 void FrameTreeNode::ResetForNewProcess() {
   current_url_ = GURL();
 
   // The children may not have been cleared if a cross-process navigation
   // commits before the old process cleans everything up.  Make sure the child
   // nodes get deleted before swapping to a new process.
   ScopedVector<FrameTreeNode> old_children = children_.Pass();
   old_children.clear();  // May notify observers.
 }
 
+void FrameTreeNode::SetOpener(FrameTreeNode* opener) {
+  if (opener_) {
+    opener_->RemoveObserver(opener_observer_.get());
+    opener_observer_.reset();
+  }
+
+  opener_ = opener;
+
+  if (opener_) {
+    if (!opener_observer_)
+      opener_observer_ = make_scoped_ptr(new OpenerDestroyedObserver(this));
+    opener_->AddObserver(opener_observer_.get());
+  }
+}
+
 void FrameTreeNode::SetCurrentOrigin(const url::Origin& origin) {
   if (!origin.IsSameAs(replication_state_.origin))
     render_manager_.OnDidUpdateOrigin(origin);
   replication_state_.origin = origin;
 }
 
 void FrameTreeNode::SetFrameName(const std::string& name) {
   if (name != replication_state_.name)
     render_manager_.OnDidUpdateName(name);
   replication_state_.name = name;
@@ skipping 148 matching lines @@
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "465796 FrameTreeNode::DidStopLoading::End"));
 }
 
 void FrameTreeNode::DidChangeLoadProgress(double load_progress) {
   loading_progress_ = load_progress;
   frame_tree_->UpdateLoadProgress();
 }
 
 }  // namespace content