Minimal Chrome Frame with Aura.

chrome/browser/ui/views/external_tab_container_win.cc

 // Copyright (c) 2012 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/ui/views/external_tab_container_win.h"
 
+#include <atlbase.h>
+#include <atlapp.h>
+#include <atlconv.h>
+#include <atlmisc.h>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/time.h"
@@ skipping 27 matching lines @@
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_view.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/ssl_status.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebReferrerPolicy.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/view_prop.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/layout/grid_layout.h"
-#include "ui/views/win/hwnd_message_handler.h"
+#include "ui/views/widget/widget.h"
+
+#if defined(USE_AURA)
+#include "ui/aura/root_window.h"
+#include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
+#endif
 
 using content::BrowserThread;
 using content::LoadNotificationDetails;
 using content::NativeWebKeyboardEvent;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::SSLStatus;
 using content::WebContents;
-using ui::ViewProp;
 using WebKit::WebCString;
 using WebKit::WebReferrerPolicy;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 
+namespace {
+
 static const char kWindowObjectKey[] = "ChromeWindowObject";
 
-namespace {
+// The following helper functions exist to localize UI toolkik-specific code.
+
+HWND HWNDFromNativeView(gfx::NativeView native_view) {
+#if defined(USE_AURA)

[sky, 2013/02/26 17:15:29]

Use c/b/ui/views/hwnd_util.h

[grt (UTC plus 2), 2013/02/27 16:53:11]

Awesome! Done.

+  if (!native_view)
+    return NULL;
+  aura::RootWindow* root_window = native_view->GetRootWindow();
+  if (!root_window)
+    return NULL;
+  return root_window->GetAcceleratedWidget();
+#else
+  return native_view;
+#endif
+}
+
+void ShowNativeView(gfx::NativeView view) {
+#if !defined(USE_AURA)
+  ::ShowWindow(view, SW_SHOWNA);
+#endif
+}
+
+scoped_ptr<content::NativeWebKeyboardEvent> CreateKeyboardEvent(
+    const MSG& msg) {
+#if defined(USE_AURA)
+  // TODO(grt): confirm that this is a translated character event.
+  ui::KeyEvent key_event(msg, true);
+  return scoped_ptr<content::NativeWebKeyboardEvent>(
+      new content::NativeWebKeyboardEvent(&key_event));
+#else
+  return scoped_ptr<content::NativeWebKeyboardEvent>(
+      new content::NativeWebKeyboardEvent(msg));
+#endif
+}
+
+const MSG& MessageFromKeyboardEvent(
+    const content::NativeWebKeyboardEvent& event) {
+#if defined(USE_AURA)
+  return event.os_event->native_event();
+#else
+  return event.os_event;
+#endif
+}
+
+// A Widget class that notifies a WidgetLifecycleDelegate when it experiences
+// lifecycle events.
+class FilteringWidget : public views::Widget {

[sky, 2013/02/26 17:15:29]

Move the methods you care about onto WidgetObserver, since it already has a
OnWidgetDestroying. You'll have to make sure there aren't any lifetime issues
with existing observers and sending something after destroyed.

[grt (UTC plus 2), 2013/02/27 16:53:11]

Done. I haven't yet found any existing WidgetObserver implementations that need
to change as a result (I'm still looking). Let me know if you know of any
particularly tricky observers that I should scrutinize.

+ public:
+  explicit FilteringWidget(WidgetLifecycleDelegate* delegate);
+  virtual ~FilteringWidget();
+
+ protected:
+  // views::internal::NativeWidgetDelegate methods.
+  virtual void OnNativeWidgetCreated() OVERRIDE;
+  virtual void OnNativeWidgetDestroying() OVERRIDE;
+  virtual void OnNativeWidgetDestroyed() OVERRIDE;
+
+ private:
+  WidgetLifecycleDelegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(FilteringWidget);
+};
+
+FilteringWidget::FilteringWidget(
+    WidgetLifecycleDelegate* delegate)
+    : delegate_(delegate) {}
+
+FilteringWidget::~FilteringWidget() {}
+
+void FilteringWidget::OnNativeWidgetCreated() {
+  views::Widget::OnNativeWidgetCreated();
+  delegate_->OnNativeWidgetCreated();
+}
+
+void FilteringWidget::OnNativeWidgetDestroying() {
+  delegate_->OnNativeWidgetDestroying();
+  views::Widget::OnNativeWidgetDestroying();
+}
+
+void FilteringWidget::OnNativeWidgetDestroyed() {
+  views::Widget::OnNativeWidgetDestroyed();
+  delegate_->OnNativeWidgetDestroyed();
+}
 
 // Convert ui::MenuModel into a serializable form for Chrome Frame
 ContextMenuModel* ConvertMenuModel(const ui::MenuModel* ui_model) {
   ContextMenuModel* new_model = new ContextMenuModel;
 
   const int item_count = ui_model->GetItemCount();
   new_model->items.reserve(item_count);
   for (int i = 0; i < item_count; ++i) {
     if (ui_model->IsVisibleAt(i)) {
       ContextMenuModel::Item item;
@@ skipping 13 matching lines @@
 }
 
 }  // namespace
 
 base::LazyInstance<ExternalTabContainerWin::PendingTabs>
     ExternalTabContainerWin::pending_tabs_ = LAZY_INSTANCE_INITIALIZER;
 
 ExternalTabContainerWin::ExternalTabContainerWin(
     AutomationProvider* automation,
     AutomationResourceMessageFilter* filter)
-    : views::NativeWidgetWin(new views::Widget),
+    : widget_(NULL),
       automation_(automation),
       tab_contents_container_(NULL),
       tab_handle_(0),
       ignore_next_load_notification_(false),
       automation_resource_message_filter_(filter),
       load_requests_via_automation_(false),
       handle_top_level_requests_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       pending_(false),
       focus_manager_(NULL),
@@ skipping 23 matching lines @@
                                    HWND parent,
                                    const gfx::Rect& bounds,
                                    DWORD style,
                                    bool load_requests_via_automation,
                                    bool handle_top_level_requests,
                                    content::WebContents* existing_contents,
                                    const GURL& initial_url,
                                    const GURL& referrer,
                                    bool infobars_enabled,
                                    bool route_all_top_level_navigations) {
-  if (IsWindow(GetNativeView())) {
+  if (widget_) {
     NOTREACHED();
     return false;
   }
 
+  widget_ = new FilteringWidget(this);
   load_requests_via_automation_ = load_requests_via_automation;
   handle_top_level_requests_ = handle_top_level_requests;
   route_all_top_level_navigations_ = route_all_top_level_navigations;

[sky, 2013/02/26 17:15:29]

See this in the member initializer list too.

[grt (UTC plus 2), 2013/02/27 16:53:11]

Done.

 
-  GetMessageHandler()->set_window_style(WS_POPUP | WS_CLIPCHILDREN);
-
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.bounds = bounds;
-  params.native_widget = this;
-  GetWidget()->Init(params);
-  if (!IsWindow(GetNativeView())) {
+#if defined(USE_AURA)
+  params.native_widget = new views::DesktopNativeWidgetAura(widget_);
+#endif
+  widget_->Init(params);
+  HWND window = HWNDFromNativeView(widget_->GetNativeView());
+
+  if (!IsWindow(window)) {

[sky, 2013/02/26 17:15:29]

I believe Widget::Init CHECKs that an HWND is created. Is this necessary?

[grt (UTC plus 2), 2013/02/27 16:53:11]

Looks like WindowImpl::Init has some CHECKs, so I think you're right, this isn't
needed. Removed.

     NOTREACHED();
     return false;
   }
 
   // TODO(jcampan): limit focus traversal to contents.
 
-  prop_.reset(new ViewProp(GetNativeView(), kWindowObjectKey, this));
+  prop_.reset(new ui::ViewProp(window, kWindowObjectKey, this));
 
   if (existing_contents) {
     existing_contents->GetController().SetBrowserContext(profile);
   } else {
     existing_contents = WebContents::Create(WebContents::CreateParams(profile));
     existing_contents->GetRenderViewHost()->AllowBindings(
         content::BINDINGS_POLICY_EXTERNAL_HOST);
   }
 
   existing_contents->SetDelegate(this);
@@ skipping 33 matching lines @@
                    weak_factory_.GetWeakPtr(),
                    initial_url, referrer));
   }
 
   // We need WS_POPUP to be on the window during initialization, but
   // once initialized we apply the requested style which may or may not
   // include the popup bit.
   // Note that it's important to do this before we call SetParent since
   // during the SetParent call we will otherwise get a WA_ACTIVATE call
   // that causes us to steal the current focus.
-  SetWindowLong(
-      GetNativeView(), GWL_STYLE,
-      (GetWindowLong(GetNativeView(), GWL_STYLE) & ~WS_POPUP) | style);
+  SetWindowLong(window, GWL_STYLE,
+                (GetWindowLong(window, GWL_STYLE) & ~WS_POPUP) | style);
 
   // Now apply the parenting and style
   if (parent)
-    SetParent(GetNativeView(), parent);
+    SetParent(window, parent);
 
-  ::ShowWindow(existing_contents->GetNativeView(), SW_SHOWNA);
+  ShowNativeView(existing_contents->GetNativeView());
 
   LoadAccelerators();
   SetupExternalTabView();
   BlockedContentTabHelper::FromWebContents(existing_contents)->
       set_delegate(this);
   return true;
 }
 
 void ExternalTabContainerWin::Uninitialize() {
   registrar_.RemoveAll();
   if (web_contents_.get()) {
+    tab_contents_container_->SetWebContents(NULL);
     UnregisterRenderViewHost(web_contents_->GetRenderViewHost());
 
     // Explicitly tell the RPH to shutdown, as doing so is the only thing that
     // cleans up certain resources like infobars (crbug.com/148398).
     // Tell the RPH to shutdown iff it has a page count of 1, meaning that
     // there is only a single remaining render widget host (the one owned by
     // web_contents_) using this RPH.
     //
     // Note that it is not possible to simply call FastShutdownIfPossible on the
     // RPH here as that unfortunately ignores RPH's internal ref count, which
     // leaves any other render widget hosts using the same RPH dangling.
     //
     // Note that in an ideal world, this would not be needed. The WebContents
     // could just destroy itself, resulting in RPH::Release() eventually getting
     // called and all would be neat and tidy. Sadly, the RPH only fires
     // NOTIFICATION_RENDERER_PROCESS_CLOSED if one of the FastShutdownXXX
     // methods is called and other components rely on that notification to avoid
     // crashing on shutdown. Sad panda. Or maybe clinically depressed panda is
     // more fitting.
     web_contents_->GetRenderProcessHost()->FastShutdownForPageCount(1);
 
-    if (GetWidget()->GetRootView())
-      GetWidget()->GetRootView()->RemoveAllChildViews(true);
+    if (widget_->GetRootView())
+      widget_->GetRootView()->RemoveAllChildViews(true);
+    widget_ = NULL;
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTERNAL_TAB_CLOSED,
         content::Source<NavigationController>(&web_contents_->GetController()),
         content::Details<ExternalTabContainer>(this));
 
     web_contents_.reset(NULL);
   }
 
   if (focus_manager_) {
     focus_manager_->UnregisterAccelerators(this);
     focus_manager_ = NULL;
   }
 
   external_tab_view_ = NULL;
   request_context_ = NULL;
   tab_contents_container_ = NULL;
 }
 
 bool ExternalTabContainerWin::Reinitialize(
     AutomationProvider* automation_provider,
     AutomationResourceMessageFilter* filter,
-    gfx::NativeWindow parent_window) {
+    HWND parent_window) {
   if (!automation_provider || !filter) {
     NOTREACHED();
     return false;
   }
 
   automation_ = automation_provider;
   automation_resource_message_filter_ = filter;
   // Wait for the automation channel to be initialized before resuming pending
   // render views and sending in the navigation state.
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&ExternalTabContainerWin::OnReinitialize,
                             weak_factory_.GetWeakPtr()));
 
   if (parent_window)
-    SetParent(GetNativeView(), parent_window);
+    SetParent(HWNDFromNativeView(widget_->GetNativeView()), parent_window);
   return true;
 }
 
 WebContents* ExternalTabContainerWin::GetWebContents() const {
   return web_contents_.get();
 }
 
-gfx::NativeView ExternalTabContainerWin::GetExternalTabNativeView() const {
-  return GetNativeView();
+HWND ExternalTabContainerWin::GetExternalTabHWND() const {
+  return HWNDFromNativeView(widget_->GetNativeView());
+}
+
+HWND ExternalTabContainerWin::GetContentHWND() const {
+  return HWNDFromNativeView(web_contents_->GetNativeView());
 }
 
 void ExternalTabContainerWin::SetTabHandle(int handle) {
   tab_handle_ = handle;
 }
 
 int ExternalTabContainerWin::GetTabHandle() const {
   return tab_handle_;
 }
 
@@ skipping 36 matching lines @@
       web_contents_.get() &&
       Browser::RunUnloadEventsHelper(web_contents_.get());
   if (!wait_for_unload_handlers) {
     AutomationMsg_RunUnloadHandlers::WriteReplyParams(reply_message, true);
     automation_->Send(reply_message);
     unload_reply_message_ = NULL;
   }
 }
 
 void ExternalTabContainerWin::ProcessUnhandledAccelerator(const MSG& msg) {
-  NativeWebKeyboardEvent keyboard_event(msg);
-  unhandled_keyboard_event_handler_.HandleKeyboardEvent(keyboard_event,
+  scoped_ptr<NativeWebKeyboardEvent> keyboard_event(CreateKeyboardEvent(msg));
+  unhandled_keyboard_event_handler_.HandleKeyboardEvent(*keyboard_event,
                                                         focus_manager_);
 }
 
 void ExternalTabContainerWin::FocusThroughTabTraversal(
     bool reverse,
     bool restore_focus_to_view) {
   DCHECK(web_contents_.get());
   if (web_contents_.get())
     web_contents_->Focus();
 
   // The web_contents_ member can get destroyed in the context of the call to
   // WebContentsViewViews::Focus() above. This method eventually calls SetFocus
   // on the native window, which could end up dispatching messages like
   // WM_DESTROY for the external tab.
   if (web_contents_.get() && restore_focus_to_view)
     web_contents_->FocusThroughTabTraversal(reverse);
 }
 
-// static
-bool ExternalTabContainerWin::IsExternalTabContainer(HWND window) {
-  return ViewProp::GetValue(window, kWindowObjectKey) != NULL;
-}
-
-// static
-ExternalTabContainer*
-    ExternalTabContainerWin::GetExternalContainerFromNativeWindow(
-        gfx::NativeView native_window) {
-  ExternalTabContainer* tab_container = NULL;
-  if (native_window) {
-    tab_container = reinterpret_cast<ExternalTabContainer*>(
-        ViewProp::GetValue(native_window, kWindowObjectKey));
-  }
-  return tab_container;
-}
 ////////////////////////////////////////////////////////////////////////////////
 // ExternalTabContainer, content::WebContentsDelegate implementation:
 
 WebContents* ExternalTabContainerWin::OpenURLFromTab(
     WebContents* source,
     const OpenURLParams& params) {
   if (pending()) {
     pending_open_url_requests_.push_back(params);
     return NULL;
   }
@@ skipping 274 matching lines @@
       web_contents(), params));
   static_cast<RenderViewContextMenuWin*>(
       external_context_menu_.get())->SetExternal();
   external_context_menu_->Init();
   external_context_menu_->UpdateMenuItemStates();
 
   scoped_ptr<ContextMenuModel> context_menu_model(
     ConvertMenuModel(&external_context_menu_->menu_model()));
 
   POINT screen_pt = { params.x, params.y };
-  MapWindowPoints(GetNativeView(), HWND_DESKTOP, &screen_pt, 1);
+  MapWindowPoints(HWNDFromNativeView(widget_->GetNativeView()), HWND_DESKTOP,
+                  &screen_pt, 1);
 
   MiniContextMenuParams ipc_params;
   ipc_params.screen_x = screen_pt.x;
   ipc_params.screen_y = screen_pt.y;
   ipc_params.link_url = params.link_url;
   ipc_params.unfiltered_link_url = params.unfiltered_link_url;
   ipc_params.src_url = params.src_url;
   ipc_params.page_url = params.page_url;
   ipc_params.keyword_url = params.keyword_url;
   ipc_params.frame_url = params.frame_url;
@@ skipping 10 matching lines @@
 bool ExternalTabContainerWin::PreHandleKeyboardEvent(
     content::WebContents* source,
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   return false;
 }
 
 void ExternalTabContainerWin::HandleKeyboardEvent(
     content::WebContents* source,
     const NativeWebKeyboardEvent& event) {
-  ProcessUnhandledKeyStroke(event.os_event.hwnd, event.os_event.message,
-                            event.os_event.wParam, event.os_event.lParam);
+  const MSG& message = MessageFromKeyboardEvent(event);
+  ProcessUnhandledKeyStroke(message.hwnd, message.message,
+                            message.wParam, message.lParam);
 }
 
 void ExternalTabContainerWin::BeforeUnloadFired(WebContents* tab,
                                                 bool proceed,
                                                 bool* proceed_to_fire_unload) {
   *proceed_to_fire_unload = true;
 
   if (!automation_) {
     delete unload_reply_message_;
     unload_reply_message_ = NULL;
@@ skipping 178 matching lines @@
         RegisterRenderViewHostForAutomation(rvh, false);
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ExternalTabContainer, views::NativeWidgetWin overrides:
+// WidgetLifecycleDelegate overrides:
 
-bool ExternalTabContainerWin::PreHandleMSG(UINT message,
-                                           WPARAM w_param,
-                                           LPARAM l_param,
-                                           LRESULT* result) {
-  if (message == WM_DESTROY) {
-    prop_.reset();
-    Uninitialize();
-  }
-  return false;
+void ExternalTabContainerWin::OnNativeWidgetCreated() {
+  // Grab a reference here which will be released in OnNativeWidgetDestroyed.
+  AddRef();
 }
 
-void ExternalTabContainerWin::PostHandleMSG(UINT message,
-                                            WPARAM w_param,
-                                            LPARAM l_param) {
-    // Grab a reference here which will be released in OnFinalMessage
-  if (message == WM_CREATE)
-    AddRef();
+void ExternalTabContainerWin::OnNativeWidgetDestroying() {
+  Uninitialize();
+  prop_.reset();
 }
 
-void ExternalTabContainerWin::OnFinalMessage(HWND window) {
-  GetWidget()->OnNativeWidgetDestroyed();
-  // Release the reference which we grabbed in WM_CREATE.
+void ExternalTabContainerWin::OnNativeWidgetDestroyed() {
+  // Release the reference which we grabbed in OnNativeWidgetCreated.
   Release();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ExternalTabContainer, private:
 bool ExternalTabContainerWin::ProcessUnhandledKeyStroke(HWND window,
                                                         UINT message,
                                                         WPARAM wparam,
                                                         LPARAM lparam) {
   if (!automation_) {
@@ skipping 150 matching lines @@
     // Nothing to do in that case.
     return;
   }
 
   scoped_array<ACCEL> scoped_accelerators(new ACCEL[count]);
   ACCEL* accelerators = scoped_accelerators.get();
   DCHECK(accelerators != NULL);
 
   CopyAcceleratorTable(accelerator_table, accelerators, count);
 
-  focus_manager_ = GetWidget()->GetFocusManager();
+  focus_manager_ = widget_->GetFocusManager();
   DCHECK(focus_manager_);
 
   // Let's fill our own accelerator table.
   for (int i = 0; i < count; ++i) {
     ui::Accelerator accelerator(
         static_cast<ui::KeyboardCode>(accelerators[i].key),
         ui::GetModifiersFromACCEL(accelerators[i]));
     accelerator_table_[accelerator] = accelerators[i].cmd;
 
     // Also register with the focus manager.
@@ skipping 57 matching lines @@
                      views::GridLayout::USE_PREF,
                      0,
                      0);
 
   external_tab_view_->SetLayoutManager(layout);
 
   layout->StartRow(0, 0);
   layout->AddView(info_bar_container);
   layout->StartRow(1, 0);
   layout->AddView(tab_contents_container_);
-  GetWidget()->SetContentsView(external_tab_view_);
+  widget_->SetContentsView(external_tab_view_);
   // Note that SetWebContents must be called after AddChildView is called
   tab_contents_container_->SetWebContents(web_contents());
 }
 
 // static
 ExternalTabContainer* ExternalTabContainer::Create(
     AutomationProvider* automation_provider,
     AutomationResourceMessageFilter* filter) {
   return new ExternalTabContainerWin(automation_provider, filter);
 }
 
 // static
 ExternalTabContainer* ExternalTabContainer::GetContainerForTab(
-    HWND tab_window) {
-  HWND parent_window = ::GetParent(tab_window);
-  if (!::IsWindow(parent_window)) {
+    content::WebContents* web_contents) {
+  HWND parent_window =
+      HWNDFromNativeView(web_contents->GetView()->GetTopLevelNativeWindow());
+  if (!::IsWindow(parent_window))
     return NULL;
-  }
-  if (!ExternalTabContainerWin::IsExternalTabContainer(parent_window)) {
-    return NULL;
-  }
-  ExternalTabContainer* container = reinterpret_cast<ExternalTabContainer*>(
-      ViewProp::GetValue(parent_window, kWindowObjectKey));
-  return container;
+  return reinterpret_cast<ExternalTabContainerWin*>(
+      ui::ViewProp::GetValue(parent_window, kWindowObjectKey));
 }
 
 // static
 scoped_refptr<ExternalTabContainer> ExternalTabContainer::RemovePendingTab(
     uintptr_t cookie) {
   return ExternalTabContainerWin::RemovePendingExternalTab(cookie);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TemporaryPopupExternalTabContainerWin
@@ skipping 16 matching lines @@
     return NULL;
 
   OpenURLParams forward_params = params;
   if (params.disposition == CURRENT_TAB) {
     DCHECK(route_all_top_level_navigations_);
     forward_params.disposition = NEW_FOREGROUND_TAB;
   }
   WebContents* new_contents =
       ExternalTabContainerWin::OpenURLFromTab(source, forward_params);
   // support only one navigation for a dummy tab before it is killed.
-  ::DestroyWindow(GetNativeView());
+  widget_->CloseNow();
   return new_contents;
 }