Minimal Chrome Frame with Aura.

chrome/browser/ui/views/external_tab_container_win.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_EXTERNAL_TAB_CONTAINER_WIN_H_
 #define CHROME_BROWSER_UI_VIEWS_EXTERNAL_TAB_CONTAINER_WIN_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/automation/automation_resource_message_filter.h"
 #include "chrome/browser/external_tab/external_tab_container.h"
 #include "chrome/browser/infobars/infobar_container.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
 #include "chrome/browser/ui/views/unhandled_keyboard_event_handler.h"
 #include "content/public/browser/navigation_type.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "ui/base/accelerators/accelerator.h"
-#include "ui/views/widget/native_widget_win.h"
 
 class AutomationProvider;
 class Browser;
 class Profile;
 class TabContentsContainer;
 class RenderViewContextMenuViews;
 struct NavigationInfo;
 
 namespace ui {
 class ViewProp;
 }
 
 namespace views {
+class View;
 class WebView;
+class Widget;
 }
 
+// A delegate interface through which an ExternalTabContainerWin is notified
+// when its native widget experiences a lifecycle event.
+class WidgetLifecycleDelegate {
+ public:
+  virtual void OnNativeWidgetCreated() = 0;
+  virtual void OnNativeWidgetDestroying() = 0;
+  virtual void OnNativeWidgetDestroyed() = 0;
+};
+
 // This class serves as the container window for an external tab.
 // An external tab is a Chrome tab that is meant to displayed in an
 // external process. This class provides the FocusManger needed by the
 // WebContents as well as an implementation of content::WebContentsDelegate.
 class ExternalTabContainerWin : public ExternalTabContainer,
                                 public content::WebContentsDelegate,
                                 public content::WebContentsObserver,
                                 public content::NotificationObserver,
-                                public views::NativeWidgetWin,
+                                public WidgetLifecycleDelegate,
                                 public ui::AcceleratorTarget,
                                 public InfoBarContainer::Delegate,
                                 public BlockedContentTabHelperDelegate {
  public:
   typedef std::map<uintptr_t,
                    scoped_refptr<ExternalTabContainerWin> > PendingTabs;
 
   ExternalTabContainerWin(AutomationProvider* automation,
                           AutomationResourceMessageFilter* filter);
 
   static scoped_refptr<ExternalTabContainer> RemovePendingExternalTab(
       uintptr_t cookie);
 
   // Overridden from ExternalTabContainer:
   virtual bool Init(Profile* profile,
                     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 supports_full_tab_mode) OVERRIDE;
   virtual void Uninitialize() OVERRIDE;
   virtual bool Reinitialize(AutomationProvider* automation_provider,
                             AutomationResourceMessageFilter* filter,
-                            gfx::NativeWindow parent_window) OVERRIDE;
+                            HWND parent_window) OVERRIDE;
   virtual content::WebContents* GetWebContents() const OVERRIDE;
-  virtual gfx::NativeView GetExternalTabNativeView() const OVERRIDE;
+  virtual HWND GetExternalTabHWND() const OVERRIDE;
+  virtual HWND GetContentHWND() const OVERRIDE;
   virtual void SetTabHandle(int handle) OVERRIDE;
   virtual int GetTabHandle() const OVERRIDE;
   virtual bool ExecuteContextMenuCommand(int command) OVERRIDE;
   virtual void RunUnloadHandlers(IPC::Message* reply_message) OVERRIDE;
   virtual void ProcessUnhandledAccelerator(const MSG& msg) OVERRIDE;
   virtual void FocusThroughTabTraversal(bool reverse,
                                         bool restore_focus_to_view) OVERRIDE;
 
-  // A helper method that tests whether the given window is an
-  // ExternalTabContainerWin window.
-  static bool IsExternalTabContainer(HWND window);
-
-  // A helper function that returns a pointer to the ExternalTabContainerWin
-  // instance associated with a native view.  Returns NULL if the window
-  // is not an ExternalTabContainerWin.
-  static ExternalTabContainer* GetExternalContainerFromNativeWindow(
-      gfx::NativeView native_window);
-
   // Overridden from content::WebContentsDelegate:
   virtual content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) OVERRIDE;
   virtual void NavigationStateChanged(const content::WebContents* source,
                                       unsigned changed_flags) OVERRIDE;
   virtual void AddNewContents(content::WebContents* source,
                               content::WebContents* new_contents,
                               WindowOpenDisposition disposition,
                               const gfx::Rect& initial_pos,
@@ skipping 99 matching lines @@
   virtual void InfoBarContainerStateChanged(bool is_animating) OVERRIDE;
   virtual bool DrawInfoBarArrows(int* x) const OVERRIDE;
 
   // Overridden from BlockedContentTabHelperDelegate:
   virtual content::WebContents* GetConstrainingWebContents(
       content::WebContents* source) OVERRIDE;
 
  protected:
   virtual ~ExternalTabContainerWin();
 
-  // Overridden from views::NativeWidgetWin:
-  virtual bool PreHandleMSG(UINT message,
-                            WPARAM w_param,
-                            LPARAM l_param,
-                            LRESULT* result) OVERRIDE;
-  virtual void PostHandleMSG(UINT message,
-                             WPARAM w_param,
-                             LPARAM l_param) OVERRIDE;
-  virtual void OnFinalMessage(HWND window);
+  // WidgetLifecycleDelegate overrides.
+  virtual void OnNativeWidgetCreated() OVERRIDE;
+  virtual void OnNativeWidgetDestroying() OVERRIDE;
+  virtual void OnNativeWidgetDestroyed() OVERRIDE;
 
   bool InitNavigationInfo(NavigationInfo* nav_info,
                           content::NavigationType nav_type,
                           int relative_offset);
   void Navigate(const GURL& url, const GURL& referrer);
 
   // Helper resource automation registration method, allowing registration of
   // pending RenderViewHosts.
   void RegisterRenderViewHostForAutomation(
       content::RenderViewHost* render_view_host,
       bool pending_view);
 
   // Helper function for processing keystokes coming back from the renderer
   // process.
   bool ProcessUnhandledKeyStroke(HWND window, UINT message, WPARAM wparam,
                                  LPARAM lparam);
 
   void LoadAccelerators();
 
   // Sends over pending Open URL requests to the external host.
   void ServicePendingOpenURLRequests();
 
   // Scheduled as a task in ExternalTabContainerWin::Reinitialize.
   void OnReinitialize();
 
   // Creates and initializes the view hierarchy for this
   // ExternalTabContainerWin.
   void SetupExternalTabView();
 
+  views::Widget* widget_;
   scoped_ptr<content::WebContents> web_contents_;
   scoped_refptr<AutomationProvider> automation_;
 
   content::NotificationRegistrar registrar_;
 
   // A view to handle focus cycling
   views::WebView* tab_contents_container_;
 
   int tab_handle_;
   // A failed navigation like a 404 is followed in chrome with a success
   // navigation for the 404 page. We need to ignore the next navigation
   // to avoid confusing the clients of the external tab. This member variable
   // is set when we need to ignore the next load notification.
   bool ignore_next_load_notification_;
 
   scoped_ptr<RenderViewContextMenuViews> external_context_menu_;
 
   // A message filter to load resources via automation
   scoped_refptr<AutomationResourceMessageFilter>
       automation_resource_message_filter_;
 
   // If all the url requests for this tab are to be loaded via automation.
   bool load_requests_via_automation_;
 
   // whether top level URL requests are to be handled by the automation client.
   bool handle_top_level_requests_;
 
+  // set to true if the host needs to get notified of all top level navigations
+  // in this page. This typically applies to hosts which would render the new
+  // page without chrome frame.
+  bool route_all_top_level_navigations_;
+
   // Contains ExternalTabContainers that have not been connected to as yet.
   static base::LazyInstance<PendingTabs> pending_tabs_;
 
   // Allows us to run tasks on the ExternalTabContainerWin instance which are
   // bound by its lifetime.
   base::WeakPtrFactory<ExternalTabContainerWin> weak_factory_;
 
   // The URL request context to be used for this tab. Can be NULL.
   scoped_refptr<ChromeURLRequestContextGetter> request_context_;
 
@@ skipping 18 matching lines @@
   // Set to true if the ExternalTabContainerWin instance is waiting for an ack
   // from the host.
   bool pending_;
 
   views::FocusManager* focus_manager_;
 
   views::View* external_tab_view_;
 
   IPC::Message* unload_reply_message_;
 
-  // set to true if the host needs to get notified of all top level navigations
-  // in this page. This typically applies to hosts which would render the new
-  // page without chrome frame.
-  bool route_all_top_level_navigations_;
-
   scoped_ptr<ui::ViewProp> prop_;
 
   // if this tab is a popup
   bool is_popup_window_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalTabContainerWin);
 };
 
 // This class is instantiated for handling requests to open popups for external
 // tabs hosted in browsers which need to be notified about all top level
@@ skipping 54 matching lines @@
     return false;
   }
 
   virtual void BeforeUnloadFired(content::WebContents* tab, bool proceed,
                                  bool* proceed_to_fire_unload) {
     NOTREACHED();
   }
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_EXTERNAL_TAB_CONTAINER_WIN_H_