Support DWM switching....

chrome/browser/views/frame/browser_view.cc

 // Copyright (c) 2006-2008 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 "base/command_line.h"
-
 #include "chrome/browser/views/frame/browser_view.h"
 
+#include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "base/time.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/app_modal_dialog_queue.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/encoding_menu_controller_delegate.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/about_chrome_view.h"
 #include "chrome/browser/views/bookmark_bar_view.h"
@@ skipping 340 matching lines @@
       accelerator_table_->begin();
   for (; it != accelerator_table_->end(); ++it) {
     if (it->second == cmd_id) {
       *accelerator = it->first;
       return true;
     }
   }
   return false;
 }
 
-bool BrowserView::SystemCommandReceived(UINT notification_code,
-                                        const gfx::Point& point) {
-  bool handled = false;
-
-  if (browser_->command_updater()->SupportsCommand(notification_code) &&
-      browser_->command_updater()->IsCommandEnabled(notification_code)) {
-    browser_->ExecuteCommand(notification_code);
-    handled = true;
-  }
-
-  return handled;
-}
-
 void BrowserView::AddViewToDropList(views::View* view) {
   dropable_views_.insert(view);
 }
 
 bool BrowserView::ActivateAppModalDialog() const {
   // If another browser is app modal, flash and activate the modal browser.
   if (AppModalDialogQueue::HasActiveDialog()) {
     Browser* active_browser = BrowserList::GetLastActive();
     if (active_browser && (browser_ != active_browser)) {
       active_browser->window()->FlashFrame();
@@ skipping 89 matching lines @@
     personalization_ = Personalization::CreateFramePersonalization(
         browser_->profile(), this);
   }
 #endif
 
   InitSystemMenu();
 }
 
 void BrowserView::Show() {
   // If the window is already visible, just activate it.
-  if (frame_->GetWindow()->IsVisible()) {
-    frame_->GetWindow()->Activate();
+  if (frame_->IsVisible()) {
+    frame_->Activate();
     return;
   }
 
   // Setting the focus doesn't work when the window is invisible, so any focus
   // initialization that happened before this will be lost.
   //
   // We really "should" restore the focus whenever the window becomes unhidden,
   // but I think initializing is the only time where this can happen where
   // there is some focus change we need to pick up, and this is easier than
   // plumbing through an un-hide message all the way from the frame.
   //
   // If we do find there are cases where we need to restore the focus on show,
   // that should be added and this should be removed.
   TabContents* selected_tab_contents = GetSelectedTabContents();
   if (selected_tab_contents)
     selected_tab_contents->RestoreFocus();
 
-  frame_->GetWindow()->Show();
-  int show_state = frame_->GetWindow()->GetShowState();
-  if (show_state == SW_SHOWNORMAL || show_state == SW_SHOWMAXIMIZED)
-    frame_->GetWindow()->Activate();
+  frame_->Show();
 }
 
 void BrowserView::SetBounds(const gfx::Rect& bounds) {
-  frame_->GetWindow()->SetBounds(bounds);
+  frame_->SetBounds(bounds);
 }
 
 void BrowserView::Close() {
-  frame_->GetWindow()->Close();
+  frame_->Close();
 }
 
 void BrowserView::Activate() {
-  frame_->GetWindow()->Activate();
+  frame_->Activate();
 }
 
 bool BrowserView::IsActive() const {
-  return frame_->GetWindow()->IsActive();
+  return frame_->IsActive();
 }
 
 void BrowserView::FlashFrame() {
   FLASHWINFO fwi;
   fwi.cbSize = sizeof(fwi);
-  fwi.hwnd = frame_->GetWindow()->GetHWND();
+  fwi.hwnd = frame_->GetHWND();
   fwi.dwFlags = FLASHW_ALL;
   fwi.uCount = 4;
   fwi.dwTimeout = 0;
   FlashWindowEx(&fwi);
 }
 
 void* BrowserView::GetNativeHandle() {
   return GetWidget()->GetHWND();
 }
 
@@ skipping 10 matching lines @@
     contents_container_->set_fast_resize(true);
     UpdateUIForContents(browser_->GetSelectedTabContents());
     contents_container_->set_fast_resize(false);
   } else {
     UpdateUIForContents(browser_->GetSelectedTabContents());
     contents_container_->UpdateHWNDBounds();
   }
 }
 
 void BrowserView::UpdateTitleBar() {
-  frame_->GetWindow()->UpdateWindowTitle();
+  frame_->UpdateWindowTitle();
   if (ShouldShowWindowIcon())
-    frame_->GetWindow()->UpdateWindowIcon();
+    frame_->UpdateWindowIcon();
 }
 
 void BrowserView::UpdateLoadingAnimations(bool should_animate) {
   if (should_animate) {
     if (!loading_animation_timer_.IsRunning()) {
       // Loads are happening, and the timer isn't running, so start it.
       loading_animation_timer_.Start(
           TimeDelta::FromMilliseconds(kLoadingAnimationFrameTimeMs), this,
           &BrowserView::LoadingAnimationCallback);
     }
@@ skipping 11 matching lines @@
 }
 
 gfx::Rect BrowserView::GetNormalBounds() const {
   // If we're in fullscreen mode, we've changed the normal bounds to the monitor
   // rect, so return the saved bounds instead.
   if (fullscreen_)
     return gfx::Rect(saved_window_info_.window_rect);
 
   WINDOWPLACEMENT wp;
   wp.length = sizeof(wp);
-  const bool ret = !!GetWindowPlacement(frame_->GetWindow()->GetHWND(), &wp);
+  const bool ret = !!GetWindowPlacement(frame_->GetHWND(), &wp);
   DCHECK(ret);
   return gfx::Rect(wp.rcNormalPosition);
 }
 
 bool BrowserView::IsMaximized() const {
-  return frame_->GetWindow()->IsMaximized();
+  return frame_->IsMaximized();
 }
 
 void BrowserView::SetFullscreen(bool fullscreen) {
   if (fullscreen_ == fullscreen)
     return;  // Nothing to do.
 
   // Move focus out of the location bar if necessary, and make it unfocusable.
   LocationBarView* location_bar = toolbar_->GetLocationBarView();
   if (!fullscreen_) {
     views::FocusManager* focus_manager = GetFocusManager();
@@ skipping 12 matching lines @@
 
   // Size/position/style window appropriately.
   views::Widget* widget = GetWidget();
   HWND hwnd = widget->GetHWND();
   if (fullscreen_) {
     // Save current window information.  We force the window into restored mode
     // before going fullscreen because Windows doesn't seem to hide the
     // taskbar if the window is in the maximized state.
     saved_window_info_.maximized = IsMaximized();
     if (saved_window_info_.maximized)
-      frame_->GetWindow()->ExecuteSystemMenuCommand(SC_RESTORE);
+      frame_->ExecuteSystemMenuCommand(SC_RESTORE);
     saved_window_info_.style = GetWindowLong(hwnd, GWL_STYLE);
     saved_window_info_.ex_style = GetWindowLong(hwnd, GWL_EXSTYLE);
     GetWindowRect(hwnd, &saved_window_info_.window_rect);
 
     // Set new window style and size.
     SetWindowLong(hwnd, GWL_STYLE,
                   saved_window_info_.style & ~(WS_CAPTION | WS_THICKFRAME));
     SetWindowLong(hwnd, GWL_EXSTYLE,
                   saved_window_info_.ex_style & ~(WS_EX_DLGMODALFRAME |
                   WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
     MONITORINFO monitor_info;
     monitor_info.cbSize = sizeof(monitor_info);
     GetMonitorInfo(MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY),
                    &monitor_info);
     gfx::Rect new_rect(monitor_info.rcMonitor);
     SetWindowPos(hwnd, NULL, new_rect.x(), new_rect.y(), new_rect.width(),
                  new_rect.height(),
                  SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
   } else {
     // Reset original window style and size.  The multiple window size/moves
     // here are ugly, but if SetWindowPos() doesn't redraw, the taskbar won't be
     // repainted.  Better-looking methods welcome.
     gfx::Rect new_rect(saved_window_info_.window_rect);
     SetWindowLong(hwnd, GWL_STYLE, saved_window_info_.style);
     SetWindowLong(hwnd, GWL_EXSTYLE, saved_window_info_.ex_style);
     SetWindowPos(hwnd, NULL, new_rect.x(), new_rect.y(), new_rect.width(),
                  new_rect.height(),
                  SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
     if (saved_window_info_.maximized)
-      frame_->GetWindow()->ExecuteSystemMenuCommand(SC_MAXIMIZE);
+      frame_->ExecuteSystemMenuCommand(SC_MAXIMIZE);
   }
 
   // Turn fullscreen bubble on or off.
   fullscreen_bubble_.reset(fullscreen_ ?
       new FullscreenExitBubble(widget, browser_.get()) : NULL);
 }
 
 bool BrowserView::IsFullscreen() const {
   return fullscreen_;
 }
@@ skipping 311 matching lines @@
   if (browser_->type() & Browser::TYPE_APP)
     return browser_->GetCurrentPageIcon();
   return SkBitmap();
 }
 
 bool BrowserView::ShouldShowWindowIcon() const {
   return SupportsWindowFeature(FEATURE_TITLEBAR);
 }
 
 bool BrowserView::ExecuteWindowsCommand(int command_id) {
+  // This function handles WM_SYSCOMMAND, WM_APPCOMMAND, and WM_COMMAND.
+
   // Translate WM_APPCOMMAND command ids into a command id that the browser
   // knows how to handle.
   int command_id_from_app_command = GetCommandIDForAppCommandID(command_id);
   if (command_id_from_app_command != -1)
     command_id = command_id_from_app_command;
 
   if (browser_->command_updater()->SupportsCommand(command_id)) {
     if (browser_->command_updater()->IsCommandEnabled(command_id))
       browser_->ExecuteCommand(command_id);
     return true;
@@ skipping 28 matching lines @@
     // position of the resulting window.
     if (IsToolbarVisible()) {
       // If we're showing the toolbar, we need to adjust |*bounds| to include
       // its desired height, since the toolbar is considered part of the
       // window's client area as far as GetWindowBoundsForClientBounds is
       // concerned...
       bounds->set_height(
           bounds->height() + toolbar_->GetPreferredSize().height());
     }
 
-    gfx::Rect window_rect = frame_->GetWindowBoundsForClientBounds(*bounds);
+    gfx::Rect window_rect =
+        frame_->GetWindowBoundsForClientBounds(*bounds);
     window_rect.set_origin(bounds->origin());
 
     // When we are given x/y coordinates of 0 on a created popup window,
     // assume none were given by the window.open() command.
     if (window_rect.x() == 0 && window_rect.y() == 0) {
       gfx::Size size = window_rect.size();
       window_rect.set_origin(WindowSizer::GetDefaultPopupOrigin(size));
     }
 
     *bounds = window_rect;
@@ skipping 34 matching lines @@
 
   // Give beforeunload handlers the chance to cancel the close before we hide
   // the window below.
   if (!browser_->ShouldCloseWindow())
     return false;
 
   if (!browser_->tabstrip_model()->empty()) {
     // Tab strip isn't empty.  Hide the frame (so it appears to have closed
     // immediately) and close all the tabs, allowing the renderers to shut
     // down. When the tab strip is empty we'll be called back again.
-    frame_->GetWindow()->Hide();
+    frame_->Hide();
     browser_->OnWindowClosing();
     return false;
   }
 
   // Empty TabStripModel, it's now safe to allow the Window to be closed.
   NotificationService::current()->Notify(
       NotificationType::WINDOW_CLOSED,
-      Source<HWND>(frame_->GetWindow()->GetHWND()),
+      Source<HWND>(frame_->GetHWND()),
       NotificationService::NoDetails());
   return true;
 }
 
 int BrowserView::NonClientHitTest(const gfx::Point& point) {
   // Since the TabStrip only renders in some parts of the top of the window,
   // the un-obscured area is considered to be part of the non-client caption
   // area of the window. So we need to treat hit-tests in these regions as
   // hit-tests of the titlebar.
 
   if (CanCurrentlyResize()) {
     CRect client_rect;
-    ::GetClientRect(frame_->GetWindow()->GetHWND(), &client_rect);
+    ::GetClientRect(frame_->GetHWND(), &client_rect);
     gfx::Size resize_corner_size = ResizeCorner::GetSize();
     gfx::Rect resize_corner_rect(client_rect.right - resize_corner_size.width(),
         client_rect.bottom - resize_corner_size.height(),
         resize_corner_size.width(), resize_corner_size.height());
     bool rtl_dir = (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT);
     if (rtl_dir)
       resize_corner_rect.set_x(0);
     if (resize_corner_rect.Contains(point)) {
       if (rtl_dir)
         return HTBOTTOMLEFT;
@@ skipping 139 matching lines @@
     return tabstrip_->OnPerformDrop(*mapped_event.get());
   }
   return DragDropTypes::DRAG_NONE;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, private:
 
 void BrowserView::InitSystemMenu() {
-  HMENU system_menu = GetSystemMenu(frame_->GetWindow()->GetHWND(), FALSE);
+  HMENU system_menu = GetSystemMenu(frame_->GetHWND(), FALSE);
   system_menu_.reset(new Menu(system_menu));
   int insertion_index = std::max(0, system_menu_->ItemCount() - 1);
   // We add the menu items in reverse order so that insertion_index never needs
   // to change.
   if (IsBrowserTypeNormal()) {
     system_menu_->AddSeparator(insertion_index);
     system_menu_->AddMenuItemWithLabel(insertion_index, IDC_TASK_MANAGER,
                                        l10n_util::GetString(IDS_TASK_MANAGER));
     // If it's a regular browser window with tabs, we don't add any more items,
     // since it already has menus (Page, Chrome).
@@ skipping 130 matching lines @@
     active_download_shelf_->Layout();
     bottom -= height;
   }
   return bottom;
 }
 
 void BrowserView::LayoutStatusBubble(int top) {
   // In restored mode, the client area has a client edge between it and the
   // frame.
   int overlap = kStatusBubbleOverlap +
-      (IsMaximized() ? 0 : views::NonClientView::kClientEdgeThickness);
+      (IsMaximized() ? 0 : views::NonClientFrameView::kClientEdgeThickness);
   gfx::Point origin(-overlap, top - kStatusBubbleHeight + overlap);
   ConvertPointToView(this, GetParent(), &origin);
   status_bubble_->SetBounds(origin.x(), origin.y(), width() / 3,
                             kStatusBubbleHeight);
 }
 
 bool BrowserView::MaybeShowBookmarkBar(TabContents* contents) {
   views::View* new_bookmark_bar_view = NULL;
   if (SupportsWindowFeature(FEATURE_BOOKMARKBAR) && contents) {
     if (!bookmark_bar_view_.get()) {
@@ skipping 224 matching lines @@
 
 // static
 void BrowserView::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_favicon_ = *rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
     initialized = true;
   }
 }
+
+// static
+BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
+  BrowserView* browser_view = new BrowserView(browser);
+  (new BrowserFrame(browser_view))->Init();
+  return browser_view;
+}
+