Minimal Chrome Frame with Aura.

chrome/browser/automation/automation_provider.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.
 
 // This implements a browser-side endpoint for UI automation activity.
 // The client-side endpoint is implemented by AutomationProxy.
 // The entire lifetime of this object should be contained within that of
 // the BrowserProcess, and in particular the NotificationService that's
 // hung off of it.
 
@@ skipping 128 matching lines @@
   virtual void OnChannelConnected(int pid) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
   IPC::Message* reply_message_release() {
     IPC::Message* reply_message = reply_message_;
     reply_message_ = NULL;
     return reply_message;
   }
 
-#if defined(OS_WIN) && !defined(USE_AURA)
+#if defined(OS_WIN)
   // Adds the external tab passed in to the tab tracker.
   bool AddExternalTab(ExternalTabContainer* external_tab);
 #endif
 
   // Get the DictionaryValue equivalent for a download item. Caller owns the
   // DictionaryValue.
   base::DictionaryValue* GetDictionaryFromDownloadItem(
       const content::DownloadItem* download,
       bool incognito);
 
@@ skipping 118 matching lines @@
 
   void KeyPress(int tab_handle, int key);
 
   void ReloadAsync(int tab_handle);
   void StopAsync(int tab_handle);
   void SaveAsAsync(int tab_handle);
 
   // Method called by the popup menu tracker when a popup menu is opened.
   void NotifyPopupMenuOpened();
 
-#if defined(OS_WIN) && !defined(USE_AURA)
+#if defined(OS_WIN)
   // The functions in this block are for use with external tabs, so they are
   // Windows only.
 
   // The container of an externally hosted tab calls this to reflect any
   // accelerator keys that it did not process. This gives the tab a chance
   // to handle the keys
   void ProcessUnhandledAccelerator(const IPC::Message& message, int handle,
                                    const MSG& msg);
 
   void SetInitialFocus(const IPC::Message& message, int handle, bool reverse,
                        bool restore_focus_to_view);
 
   void OnTabReposition(int tab_handle,
                        const Reposition_Params& params);
 
   void OnForwardContextMenuCommandToChrome(int tab_handle, int command);
 
   void CreateExternalTab(const ExternalTabSettings& settings,
-                         gfx::NativeWindow* tab_container_window,
-                         gfx::NativeWindow* tab_window,
+                         HWND* tab_container_window,
+                         HWND* tab_window,
                          int* tab_handle,
                          int* session_id);
 
   void ConnectExternalTab(uint64 cookie,
                           bool allow,
-                          gfx::NativeWindow parent_window,
-                          gfx::NativeWindow* tab_container_window,
-                          gfx::NativeWindow* tab_window,
+                          HWND parent_window,
+                          HWND* tab_container_window,
+                          HWND* tab_window,
                           int* tab_handle,
                           int* session_id);
 
   void NavigateInExternalTab(
       int handle, const GURL& url, const GURL& referrer,
       AutomationMsg_NavigationResponseValues* status);
   void NavigateExternalTabAtIndex(
       int handle, int index, AutomationMsg_NavigationResponseValues* status);
 
   // Handler for a message sent by the automation client.
   void OnMessageFromExternalHost(int handle, const std::string& message,
                                  const std::string& origin,
                                  const std::string& target);
 
   void OnBrowserMoved(int handle);
 
   void OnRunUnloadHandlers(int handle, IPC::Message* reply_message);
 
   void OnSetZoomLevel(int handle, int zoom_level);
 
   ExternalTabContainer* GetExternalTabForHandle(int handle);
-#endif  // defined(OS_WIN) && !defined(USE_AURA)
+#endif  // defined(OS_WIN)
 
   scoped_ptr<IPC::ChannelProxy> channel_;
   scoped_ptr<NewTabUILoadObserver> new_tab_ui_load_observer_;
   scoped_ptr<FindInPageNotificationObserver> find_in_page_observer_;
 
   // True iff we should enable observers that check for initial load conditions.
   bool use_initial_load_observers_;
 
   // True iff connected to an AutomationProxy.
   bool is_connected_;
@@ skipping 11 matching lines @@
   std::string channel_id_;
 
   // Trace data that has been collected but not flushed to the automation
   // client.
   TracingData tracing_data_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationProvider);
 };
 
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_H_