Fix cross-window focus in Chrome Frame.

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 <atlcrack.h>
@@ skipping 63 matching lines @@
 #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/widget/widget.h"
 #include "ui/views/win/hwnd_util.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/root_window.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
+#include "ui/views/widget/desktop_aura/desktop_root_window_host_win.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;
@@ skipping 129 matching lines @@
 
   void OnSize(UINT type, const CSize& size) {
     ::SetWindowPos(child_, NULL, 0, 0, size.cx, size.cy,
                    SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
   }
 
   HWND child_;
 
   DISALLOW_COPY_AND_ASSIGN(ContainerWindow);
 };
+
+// A specialization of DesktopRootWindowHost for an external tab container that
+// saves and restores focus as the ETC is blurred and focused. DRWHW ordinarily
+// does this during window activation and deactivation. Since the ETC is a child
+// window, it does not receive activation messages.
+class ExternalTabRootWindowHost : public views::DesktopRootWindowHostWin {
+ public:
+  ExternalTabRootWindowHost(
+      views::internal::NativeWidgetDelegate* native_widget_delegate,
+      views::DesktopNativeWidgetAura* desktop_native_widget_aura,
+      const gfx::Rect& initial_bounds)
+      : views::DesktopRootWindowHostWin(native_widget_delegate,
+                                        desktop_native_widget_aura,
+                                        initial_bounds) {}
+
+ protected:
+  // HWNDMessageHandlerDelegate methods:
+  virtual void HandleNativeFocus(HWND last_focused_window) OVERRIDE {
+    views::DesktopRootWindowHostWin::HandleNativeFocus(last_focused_window);
+    RestoreFocusOnActivate();
+  }
+
+  virtual void HandleNativeBlur(HWND focused_window) OVERRIDE {
+    SaveFocusOnDeactivate();
+    views::DesktopRootWindowHostWin::HandleNativeBlur(focused_window);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ExternalTabRootWindowHost);
+};
 #endif
 
 base::LazyInstance<ExternalTabContainerWin::PendingTabs>
     ExternalTabContainerWin::pending_tabs_ = LAZY_INSTANCE_INITIALIZER;
 
 ExternalTabContainerWin::ExternalTabContainerWin(
     AutomationProvider* automation,
     AutomationResourceMessageFilter* filter)
     : widget_(NULL),
       automation_(automation),
@@ skipping 54 matching lines @@
   route_all_top_level_navigations_ = route_all_top_level_navigations;
 
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.bounds = bounds;
 #if defined(USE_AURA)
   // Create the window that sits between the parent (most likely a
   // ChromeFrameAutomationClient) and the DesktopRootWindowHostWin.
   tab_container_window_ =
       (new ContainerWindow(HWND_DESKTOP, params.bounds))->AsWeakPtr();
 
-  params.native_widget = new views::DesktopNativeWidgetAura(widget_);
+  views::DesktopNativeWidgetAura* native_widget =
+      new views::DesktopNativeWidgetAura(widget_);
+  params.native_widget = native_widget;
+  params.desktop_root_window_host =
+      new ExternalTabRootWindowHost(widget_, native_widget, params.bounds);
   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
   params.opacity = views::Widget::InitParams::OPAQUE_WINDOW;
 #endif
   widget_->Init(params);
 
 #if defined(USE_AURA)
   tab_container_window_->SetChild(views::HWNDForWidget(widget_));
 #endif
 
   // TODO(jcampan): limit focus traversal to contents.
@@ skipping 435 matching lines @@
 bool ExternalTabContainerWin::TakeFocus(content::WebContents* source,
                                         bool reverse) {
   if (automation_) {
     automation_->Send(new AutomationMsg_TabbedOut(tab_handle_,
         base::win::IsShiftPressed()));
   }
 
   return true;
 }
 
+void ExternalTabContainerWin::WebContentsFocused(
+    content::WebContents* contents) {
+  DCHECK_EQ(tab_contents_container_->GetWebContents(), contents);
+  tab_contents_container_->OnWebContentsFocused(contents);
+}
+
 void ExternalTabContainerWin::CanDownload(
     RenderViewHost* render_view_host,
     int request_id,
     const std::string& request_method,
     const base::Callback<void(bool)>& callback) {
   if (load_requests_via_automation_) {
     if (automation_) {
       // In case the host needs to show UI that needs to take the focus.
       ::AllowSetForegroundWindow(ASFW_ANY);
 
@@ skipping 625 matching lines @@
   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.
   widget_->CloseNow();
   return new_contents;
 }