Move guest lifetime management to chrome

chrome/browser/guest_view/guest_view_base.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 "chrome/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "chrome/browser/guest_view/ad_view/ad_view_guest.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
 #include "chrome/browser/guest_view/guest_view_manager.h"
@@ skipping 22 matching lines @@
     : name_(name), args_(args.Pass()) {
 }
 
 GuestViewBase::Event::~Event() {
 }
 
 scoped_ptr<base::DictionaryValue> GuestViewBase::Event::GetArguments() {
   return args_.Pass();
 }
 
+class GuestViewBase::EmbedderWebContentsObserver : public WebContentsObserver {

[lazyboy, 2014/05/29 19:13:58]

Add a note saying this observer ensures we destroy ourselves when our embedder's
WC goes away.

[Fady Samuel, 2014/05/29 21:21:12]

Done.

+ public:
+  explicit EmbedderWebContentsObserver(GuestViewBase* guest)
+      : WebContentsObserver(guest->embedder_web_contents()),
+        guest_(guest) {
+  }
+
+  virtual ~EmbedderWebContentsObserver() {
+  }
+
+  // WebContentsObserver implementation.
+  virtual void WebContentsDestroyed() OVERRIDE {
+    guest_->embedder_web_contents_ = NULL;
+    guest_->EmbedderDestroyed();
+    guest_->Destroy();
+  }
+
+ private:
+  GuestViewBase* guest_;
+
+  DISALLOW_COPY_AND_ASSIGN(EmbedderWebContentsObserver);
+};
+
 GuestViewBase::GuestViewBase(int guest_instance_id,
                              WebContents* guest_web_contents,
                              const std::string& embedder_extension_id)
-    : guest_web_contents_(guest_web_contents),
+    : WebContentsObserver(guest_web_contents),
       embedder_web_contents_(NULL),
       embedder_extension_id_(embedder_extension_id),
       embedder_render_process_id_(0),
       browser_context_(guest_web_contents->GetBrowserContext()),
       guest_instance_id_(guest_instance_id),
       view_instance_id_(guestview::kInstanceIDNone),
       weak_ptr_factory_(this) {
   guest_web_contents->SetDelegate(this);
   webcontents_guestview_map.Get().insert(
       std::make_pair(guest_web_contents, this));
@@ skipping 91 matching lines @@
                                   incognito));
 }
 
 base::WeakPtr<GuestViewBase> GuestViewBase::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void GuestViewBase::Attach(content::WebContents* embedder_web_contents,
                            const base::DictionaryValue& args) {
   embedder_web_contents_ = embedder_web_contents;
+  embedder_web_contents_observer_.reset(
+      new EmbedderWebContentsObserver(this));
   embedder_render_process_id_ =
       embedder_web_contents->GetRenderProcessHost()->GetID();
   args.GetInteger(guestview::kParameterInstanceId, &view_instance_id_);
   extra_params_.reset(args.DeepCopy());
 
   // GuestViewBase::Attach is called prior to initialization (and initial
   // navigation) of the guest in the content layer in order to permit mapping
   // the necessary associations between the <*view> element and its guest. This
   // is needed by the <webview> WebRequest API to allow intercepting resource
   // requests during navigation. However, queued events should be fired after
   // content layer initialization in order to ensure that load events (such as
   // 'loadstop') fire in embedder after the contentWindow is available.
   if (!in_extension())
     return;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GuestViewBase::SendQueuedEvents,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void GuestViewBase::Destroy() {
   if (!destruction_callback_.is_null())
-    destruction_callback_.Run(guest_web_contents());
+    destruction_callback_.Run();
   delete guest_web_contents();
 }
 
 
 void GuestViewBase::SetOpener(GuestViewBase* guest) {
   if (guest && guest->IsViewType(GetViewType())) {
     opener_ = guest->AsWeakPtr();
     return;
   }
   opener_ = base::WeakPtr<GuestViewBase>();
 }
 
 void GuestViewBase::RegisterDestructionCallback(
     const DestructionCallback& callback) {
   destruction_callback_ = callback;
 }
 
+void GuestViewBase::WebContentsDestroyed() {
+  delete this;
+}
+
 bool GuestViewBase::ShouldFocusPageAfterCrash() {
   // Focus is managed elsewhere.
   return false;
 }
 
 bool GuestViewBase::PreHandleGestureEvent(content::WebContents* source,
                                          const blink::WebGestureEvent& event) {
   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
       event.type == blink::WebGestureEvent::GesturePinchUpdate ||
       event.type == blink::WebGestureEvent::GesturePinchEnd;
@@ skipping 42 matching lines @@
 
 void GuestViewBase::SendQueuedEvents() {
   if (!attached())
     return;
   while (!pending_events_.empty()) {
     linked_ptr<Event> event_ptr = pending_events_.front();
     pending_events_.pop_front();
     DispatchEvent(event_ptr.release());
   }
 }