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 12 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/repost_form_warning_controller.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/app_modal_dialogs/javascript_dialog_manager.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tab_contents.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/media_stream_infobar_delegate.h"
 #include "chrome/browser/ui/tab_modal_confirm_dialog.h"
+#include "chrome/browser/ui/views/hwnd_util.h"
 #include "chrome/browser/ui/views/infobars/infobar_container_view.h"
 #include "chrome/browser/ui/views/tab_contents/render_view_context_menu_win.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #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"
@@ skipping 14 matching lines @@
 #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.

[robertshield, 2013/02/27 21:15:42]

kik -> kit

[grt (UTC plus 2), 2013/02/28 02:48:41]

Done.

+
+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
+}
 
 // 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),
+      route_all_top_level_navigations_(false),

[robertshield, 2013/02/27 21:15:42]

just curious, was there a functional reason to change the order this member was
declared in in the header file?

[grt (UTC plus 2), 2013/02/28 02:48:41]

Mostly just for style: when I see three bool members set in a row in an Init()
function, I think it makes sense for those three bool members to live next to
one another in memory. That aside, it does make sense to group bool members
together for the sake of packing the members into memory. You can end up with a
lot of wasted space if you have bools sprinkled about among wider data types. I
wouldn't be opposed to a loose guideline in Chromium that members be ordered in
decreasing size within a class for better packing. Note that I'm wise enough to
not say this in public. Oh shucks, I just did.

       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       pending_(false),
       focus_manager_(NULL),
       external_tab_view_(NULL),
       unload_reply_message_(NULL),
-      route_all_top_level_navigations_(false),
       is_popup_window_(false) {
 }
 
 // static
 scoped_refptr<ExternalTabContainer>
     ExternalTabContainerWin::RemovePendingExternalTab(uintptr_t cookie) {
   PendingTabs& pending_tabs = pending_tabs_.Get();
   PendingTabs::iterator index = pending_tabs.find(cookie);
   if (index != pending_tabs.end()) {
     scoped_refptr<ExternalTabContainer> container = (*index).second;
@@ skipping 10 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 views::Widget();
+  widget_->AddObserver(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;
 
-  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())) {
-    NOTREACHED();
-    return false;
-  }
+#if defined(USE_AURA)
+  params.native_widget = new views::DesktopNativeWidgetAura(widget_);
+#endif
+  widget_->Init(params);
+  HWND window = chrome::HWNDForWidget(widget_);
 
   // 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->GetView()->GetNativeView(), SW_SHOWNA);
+  ShowNativeView(existing_contents->GetView()->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(chrome::HWNDForWidget(widget_), parent_window);

[robertshield, 2013/02/27 21:15:42]

should this, and other occurrences of this call be replaced by
GetExternalTabHWND() ?

[grt (UTC plus 2), 2013/02/28 02:48:41]

That would certainly work, but I don't like that it adds the cost of virtual
dispatch to places where it isn't necessary.

   return true;
 }
 
 WebContents* ExternalTabContainerWin::GetWebContents() const {
   return web_contents_.get();
 }
 
-gfx::NativeView ExternalTabContainerWin::GetExternalTabNativeView() const {
-  return GetNativeView();
+HWND ExternalTabContainerWin::GetExternalTabHWND() const {
+  return chrome::HWNDForWidget(widget_);
+}
+
+HWND ExternalTabContainerWin::GetContentHWND() const {
+  return chrome::HWNDForNativeWindow(web_contents_->GetView()->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_->GetView()->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(chrome::HWNDForWidget(widget_), 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:
+// WidgetObserver 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::OnWidgetCreated(views::Widget* widget) {
+  DCHECK_EQ(widget_, widget);
+  // Grab a reference here which will be released in OnWidgetDestroyed.
+  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::OnWidgetDestroying(views::Widget* widget) {
+  DCHECK_EQ(widget_, widget);
+  Uninitialize();
+  prop_.reset();
 }
 
-void ExternalTabContainerWin::OnFinalMessage(HWND window) {
-  GetWidget()->OnNativeWidgetDestroyed();
-  // Release the reference which we grabbed in WM_CREATE.
+void ExternalTabContainerWin::OnWidgetDestroyed(views::Widget* widget) {
+  DCHECK_EQ(widget_, static_cast<views::Widget*>(NULL));
+  // Release the reference which we grabbed in OnWidgetCreated.
   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 = chrome::HWNDForNativeWindow(
+      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;
 }