Getting rid of more webview memory leaks.

components/guest_view/browser/guest_view_manager.cc

 // 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.
 
 #include "components/guest_view/browser/guest_view_manager.h"
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "components/guest_view/browser/guest_view_base.h"
 #include "components/guest_view/browser/guest_view_manager_delegate.h"
@@ skipping 227 matching lines @@
       if (instance_id != last_instance_id_removed_ + 1)
         break;
       ++last_instance_id_removed_;
       removed_instance_ids_.erase(iter++);
     }
   } else {
     removed_instance_ids_.insert(guest_instance_id);
   }
 }
 
+void GuestViewManager::ViewCreated(int embedder_process_id,
+                                   int view_instance_id,
+                                   const std::string& view_type) {
+  if (guest_view_registry_.empty())
+    RegisterGuestViewTypes();
+  auto view_it = guest_view_registry_.find(view_type);
+  CHECK(view_it != guest_view_registry_.end())
+      << "Invalid GuestView created of type \"" << view_type << "\"";
+
+  // Register the cleanup callback for when this view is destroyed.
+  RegisterViewDestructionCallback(embedder_process_id,
+                                  view_instance_id,
+                                  base::Bind(view_it->second.cleanup_function,
+                                             embedder_process_id,
+                                             view_instance_id));
+}
+
+void GuestViewManager::ViewGarbageCollected(int embedder_process_id,
+                                            int view_instance_id) {
+  // Find and call any callbacks associated with the view that has been garbage
+  // collected.
+  auto embedder_it = view_destruction_callback_map_.find(embedder_process_id);
+  if (embedder_it == view_destruction_callback_map_.end())
+    return;
+  CallbacksForEachViewID& callbacks_for_embedder = embedder_it->second;
+  auto view_it = callbacks_for_embedder.find(view_instance_id);
+  if (view_it == callbacks_for_embedder.end())
+    return;
+  Callbacks& callbacks_for_view = view_it->second;
+  for (auto& callback : callbacks_for_view)
+    callback.Run();
+  callbacks_for_embedder.erase(view_it);
+}
+
 GuestViewBase* GuestViewManager::CreateGuestInternal(
     content::WebContents* owner_web_contents,
     const std::string& view_type) {
   if (guest_view_registry_.empty())
     RegisterGuestViewTypes();
 
   auto it = guest_view_registry_.find(view_type);
   if (it == guest_view_registry_.end()) {
     NOTREACHED();
     return nullptr;
   }
 
-  return it->second.Run(owner_web_contents);
+  return it->second.create_function.Run(owner_web_contents);
 }
 
 void GuestViewManager::RegisterGuestViewTypes() {
   delegate_->RegisterAdditionalGuestViewTypes();
 }
 
+void GuestViewManager::RegisterViewDestructionCallback(
+    int embedder_process_id,
+    int view_instance_id,
+    const base::Closure& callback) {
+  view_destruction_callback_map_[embedder_process_id][view_instance_id]
+      .push_back(callback);
+}
+
 bool GuestViewManager::IsGuestAvailableToContext(GuestViewBase* guest) {
   return delegate_->IsGuestAvailableToContext(guest);
 }
 
 void GuestViewManager::DispatchEvent(const std::string& event_name,
                                      scoped_ptr<base::DictionaryValue> args,
                                      GuestViewBase* guest,
                                      int instance_id) {
   // TODO(fsamuel): GuestViewManager should probably do something more useful
   // here like log an error if the event could not be dispatched.
   delegate_->DispatchEvent(event_name, args.Pass(), guest, instance_id);
 }
 
+void GuestViewManager::EmbedderWillBeDestroyed(int embedder_process_id) {
+  // Find and call any callbacks associated with the embedder that is being
+  // destroyed.
+  auto embedder_it = view_destruction_callback_map_.find(embedder_process_id);
+  if (embedder_it == view_destruction_callback_map_.end())
+    return;
+  CallbacksForEachViewID& callbacks_for_embedder = embedder_it->second;
+  for (auto& view_pair : callbacks_for_embedder) {
+    Callbacks& callbacks_for_view = view_pair.second;
+    for (auto& callback : callbacks_for_view) {
+      callback.Run();
+    }
+  }
+  view_destruction_callback_map_.erase(embedder_it);
+}
+
 content::WebContents* GuestViewManager::GetGuestByInstanceID(
     int guest_instance_id) {
   auto it = guest_web_contents_by_instance_id_.find(guest_instance_id);
   if (it == guest_web_contents_by_instance_id_.end())
     return nullptr;
   return it->second;
 }
 
 bool GuestViewManager::CanEmbedderAccessInstanceIDMaybeKill(
     int embedder_render_process_id,
@@ skipping 73 matching lines @@
     const GuestViewManager::ElementInstanceKey& other) const {
   if (embedder_process_id != other.embedder_process_id)
     return embedder_process_id < other.embedder_process_id;
 
   return element_instance_id < other.element_instance_id;
 }
 
 bool GuestViewManager::ElementInstanceKey::operator==(
     const GuestViewManager::ElementInstanceKey& other) const {
   return (embedder_process_id == other.embedder_process_id) &&
-    (element_instance_id == other.element_instance_id);
+         (element_instance_id == other.element_instance_id);
 }
 
+GuestViewManager::GuestViewData::GuestViewData(
+    const GuestViewCreateFunction& create_function,
+    const GuestViewCleanUpFunction& cleanup_function)
+    : create_function(create_function), cleanup_function(cleanup_function) {}
+
+GuestViewManager::GuestViewData::~GuestViewData() {}
+
 }  // namespace guest_view