This patch improves the way that GuestViewManager tracks the destruction of GuestView embedders.

components/guest_view/browser/guest_view_manager.h

 // Copyright 2014 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 COMPONENTS_GUEST_VIEW_BROWSER_GUEST_VIEW_MANAGER_H_
 #define COMPONENTS_GUEST_VIEW_BROWSER_GUEST_VIEW_MANAGER_H_
 
 #include <map>
+#include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/gtest_prod_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 
 class GURL;
 
 namespace content {
 class BrowserContext;
 class WebContents;
 }  // namespace content
@@ skipping 100 matching lines @@
   bool ForEachGuest(content::WebContents* owner_web_contents,
                     const GuestCallback& callback) override;
   content::WebContents* GetFullPageGuest(
       content::WebContents* embedder_web_contents) override;
 
  protected:
   friend class GuestViewBase;
   friend class GuestViewEvent;
   friend class GuestViewMessageFilter;
 
+  class EmbedderRenderProcessHostObserver;
+
   // These methods are virtual so that they can be overriden in tests.
 
   virtual void AddGuest(int guest_instance_id,
                         content::WebContents* guest_web_contents);
   virtual void RemoveGuest(int guest_instance_id);
 
   // This method is called when the embedder process with ID
-  // |embedder_process_id| is about to be destroyed.
-  virtual void EmbedderWillBeDestroyed(int embedder_process_id);
+  // |embedder_process_id| has been destroyed.
+  virtual void EmbedderProcessDestroyed(int embedder_process_id);
 
   // Called when a GuestView has been created in JavaScript.
   virtual void ViewCreated(int embedder_process_id,
                            int view_instance_id,
                            const std::string& view_type);
 
   // Called when a GuestView has been garbage collected in JavaScript.
   virtual void ViewGarbageCollected(int embedder_process_id,
                                     int view_instance_id);
 
+  // Calls all destruction callbacks registered for the GuestView identified by
+  // |embedder_process_id| and |view_instance_id|.
+  void CallViewDestructionCallbacks(int embedder_process_id,
+                                    int view_instance_id);
+
+  // Calls all destruction callbacks registered for GuestViews in the embedder
+  // with ID |embedder_process_id|.
+  void CallViewDestructionCallbacks(int embedder_process_id);
+
   // Creates a guest of the provided |view_type|.
   GuestViewBase* CreateGuestInternal(content::WebContents* owner_web_contents,
                                      const std::string& view_type);
 
   // Adds GuestView types to the GuestView registry.
   void RegisterGuestViewTypes();
 
   // Indicates whether the provided |guest| can be used in the context it has
   // been created.
   bool IsGuestAvailableToContext(GuestViewBase* guest);
@@ skipping 44 matching lines @@
 
   using GuestInstanceIDMap = std::map<ElementInstanceKey, int>;
   GuestInstanceIDMap instance_id_map_;
 
   // The reverse map of GuestInstanceIDMap.
   using GuestInstanceIDReverseMap = std::map<int, ElementInstanceKey>;
   GuestInstanceIDReverseMap reverse_instance_id_map_;
 
   using GuestViewCreateFunction =
       base::Callback<GuestViewBase*(content::WebContents*)>;
-  using GuestViewCleanUpFunction = base::Callback<void(int, int)>;
+  using GuestViewCleanUpFunction =
+      base::Callback<void(content::BrowserContext*, int, int)>;
   struct GuestViewData {
     GuestViewData(const GuestViewCreateFunction& create_function,
                   const GuestViewCleanUpFunction& cleanup_function);
     ~GuestViewData();
     const GuestViewCreateFunction create_function;
     const GuestViewCleanUpFunction cleanup_function;
   };
   using GuestViewMethodMap = std::map<std::string, GuestViewData>;
   GuestViewMethodMap guest_view_registry_;
 
   int current_instance_id_;
 
   // Any instance ID whose number not greater than this was removed via
   // RemoveGuest.
   // This is used so that we don't have store all removed instance IDs in
   // |removed_instance_ids_|.
   int last_instance_id_removed_;
   // The remaining instance IDs that are greater than
   // |last_instance_id_removed_| are kept here.
   std::set<int> removed_instance_ids_;
 
   content::BrowserContext* context_;
 
   scoped_ptr<GuestViewManagerDelegate> delegate_;
 
+  // This tracks which GuestView embedders are currently being observed.
+  std::set<int> embedders_observed_;
+
   // |view_destruction_callback_map_| maps from embedder process ID to view ID
   // to a vector of callback functions to be called when that view is destroyed.
   using Callbacks = std::vector<base::Closure> ;
   using CallbacksForEachViewID = std::map<int, Callbacks> ;
   using CallbacksForEachEmbedderID = std::map<int, CallbacksForEachViewID> ;
   CallbacksForEachEmbedderID view_destruction_callback_map_;
 
+  // This is used to ensure that an EmbedderRenderProcessHostObserver will not
+  // call into this GuestViewManager after it has been destroyed.
+  base::WeakPtrFactory<GuestViewManager> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GuestViewManager);
 };
 
 }  // namespace guest_view
 
 #endif  // COMPONETS_GUEST_VIEW_BROWSER_GUEST_VIEW_MANAGER_H_