Make toolbar compile on linux.

chrome/browser/views/toolbar_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 "chrome/browser/views/toolbar_view.h"
 
 #include <string>
 
 #include "app/drag_drop_types.h"
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/user_data_manager.h"
 #include "chrome/browser/views/bookmark_menu_button.h"
-#include "chrome/browser/views/dom_view.h"
 #include "chrome/browser/views/event_utils.h"
 #include "chrome/browser/views/go_button.h"
 #include "chrome/browser/views/location_bar_view.h"
-#include "chrome/browser/views/theme_helpers.h"
 #include "chrome/browser/views/toolbar_star_toggle.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #ifdef CHROME_PERSONALIZATION
 #include "chrome/personalization/personalization.h"
 #endif
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "views/background.h"
 #include "views/controls/button/button_dropdown.h"
-#include "views/controls/hwnd_view.h"
 #include "views/controls/label.h"
+#if defined(OS_WIN)
 #include "views/drag_utils.h"
 #include "views/widget/tooltip_manager.h"
+#endif
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 
 static const int kControlHorizOffset = 4;
 static const int kControlVertOffset = 6;
 static const int kControlIndent = 3;
 static const int kStatusBubbleWidth = 480;
 
 // Separation between the location bar and the menus.
 static const int kMenuButtonOffset = 3;
@@ skipping 11 matching lines @@
 // The number of pixels of margin on the buttons on either side of the omnibox.
 // We use this value to inset the bounds returned for the omnibox popup, since
 // we want the popup to be only as wide as the visible frame of the omnibox.
 static const int kOmniboxButtonsHorizontalMargin = 2;
 
 static SkBitmap* kPopupBackgroundEdge = NULL;
 
 BrowserToolbarView::BrowserToolbarView(Browser* browser)
     : EncodingMenuControllerDelegate(browser),
       model_(browser->toolbar_model()),
+      acc_focused_view_(NULL),
       back_(NULL),
       forward_(NULL),
       reload_(NULL),
       home_(NULL),
       star_(NULL),
       location_bar_(NULL),
       go_(NULL),
+      page_menu_(NULL),
+      app_menu_(NULL),
+      bookmark_menu_(NULL),
       profile_(NULL),
-      acc_focused_view_(NULL),
       browser_(browser),
       tab_(NULL),
-      profiles_helper_(new GetProfilesHelper(this)),
-      profiles_menu_(NULL) {
+      profiles_menu_(NULL),      
+      profiles_helper_(new GetProfilesHelper(this)) {
   browser_->command_updater()->AddCommandObserver(IDC_BACK, this);
   browser_->command_updater()->AddCommandObserver(IDC_FORWARD, this);
   browser_->command_updater()->AddCommandObserver(IDC_RELOAD, this);
   browser_->command_updater()->AddCommandObserver(IDC_HOME, this);
   browser_->command_updater()->AddCommandObserver(IDC_STAR, this);
   back_menu_model_.reset(new BackForwardMenuModelWin(
       browser, BackForwardMenuModel::BACKWARD_MENU_DELEGATE));
   forward_menu_model_.reset(new BackForwardMenuModelWin(
       browser, BackForwardMenuModel::FORWARD_MENU_DELEGATE));
   if (browser->type() == Browser::TYPE_NORMAL)
@@ skipping 92 matching lines @@
   go_->SetID(VIEW_ID_GO_BUTTON);
 
   LoadCenterStackImages();
 
   AddChildView(location_bar_);
   location_bar_->Init();
   AddChildView(go_);
 }
 
 void BrowserToolbarView::CreateRightSideControls(Profile* profile) {
-  ThemeProvider* tp = GetThemeProvider();
-
   page_menu_ = new views::MenuButton(NULL, std::wstring(), this, false);
   page_menu_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_PAGE));
   page_menu_->SetTooltipText(l10n_util::GetString(IDS_PAGEMENU_TOOLTIP));
   page_menu_->SetID(VIEW_ID_PAGE_MENU);
 
 
   app_menu_ = new views::MenuButton(NULL, std::wstring(), this, false);
   app_menu_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_APP));
   app_menu_->SetTooltipText(l10n_util::GetStringF(IDS_APPMENU_TOOLTIP,
       l10n_util::GetString(IDS_PRODUCT_NAME)));
@@ skipping 197 matching lines @@
   }
 
   // For glass, we need to draw a black line below the location bar to separate
   // it from the content area.  For non-glass, the NonClientView draws the
   // toolbar background below the location bar for us.
   if (GetWindow()->GetNonClientView()->UseNativeFrame())
     canvas->FillRectInt(SK_ColorBLACK, 0, height() - 1, width(), 1);
 }
 
 void BrowserToolbarView::DidGainFocus() {
+#if defined(OS_WIN)
   // Check to see if MSAA focus should be restored to previously focused button,
   // and if button is an enabled, visibled child of toolbar.
   if (!acc_focused_view_ ||
       (acc_focused_view_->GetParent()->GetID() != VIEW_ID_TOOLBAR) ||
       !acc_focused_view_->IsEnabled() ||
       !acc_focused_view_->IsVisible()) {
     // Find first accessible child (-1 to start search at parent).
     int first_acc_child = GetNextAccessibleViewIndex(-1, false);
 
     // No buttons enabled or visible.
@@ skipping 16 matching lines @@
 
     // Update focused_view with MSAA-adjusted child id.
     view_index = acc_focused_view_->GetID();
   }
 
   gfx::NativeView wnd = GetWidget()->GetNativeView();
 
   // Notify Access Technology that there was a change in keyboard focus.
   ::NotifyWinEvent(EVENT_OBJECT_FOCUS, wnd, OBJID_CLIENT,
                    static_cast<LONG>(view_index));
+#else
+  // TODO(port): deal with toolbar a11y focus.
+  NOTIMPLEMENTED();
+#endif
 }
 
 void BrowserToolbarView::WillLoseFocus() {
+#if defined(OS_WIN)
   if (acc_focused_view_) {
     // Resetting focus state.
     acc_focused_view_->SetHotTracked(false);
   }
   // Any tooltips that are active should be hidden when toolbar loses focus.
   if (GetWidget() && GetWidget()->GetTooltipManager())
     GetWidget()->GetTooltipManager()->HideKeyboardTooltip();
+#else
+  // TODO(port): deal with toolbar a11y focus.
+  NOTIMPLEMENTED();
+#endif
 }
 
 bool BrowserToolbarView::OnKeyPressed(const views::KeyEvent& e) {
+#if defined(OS_WIN)
   // Paranoia check, button should be initialized upon toolbar gaining focus.
   if (!acc_focused_view_)
     return false;
 
   int focused_view = GetChildIndex(acc_focused_view_);
   int next_view = focused_view;
 
   switch (e.GetCharacter()) {
     case VK_LEFT:
       next_view = GetNextAccessibleViewIndex(focused_view, true);
@@ skipping 47 matching lines @@
     // Show the tooltip for the view that got the focus.
     if (GetWidget()->GetTooltipManager()) {
       GetWidget()->GetTooltipManager()->
           ShowKeyboardTooltip(GetChildViewAt(next_view));
     }
     // Notify Access Technology that there was a change in keyboard focus.
     ::NotifyWinEvent(EVENT_OBJECT_FOCUS, wnd, OBJID_CLIENT,
                      static_cast<LONG>(view_id));
     return true;
   }
+#else
+  // TODO(port): deal with toolbar a11y focus.
+  NOTIMPLEMENTED();
+#endif
   return false;
 }
 
 bool BrowserToolbarView::OnKeyReleased(const views::KeyEvent& e) {
   // Paranoia check, button should be initialized upon toolbar gaining focus.
   if (!acc_focused_view_)
     return false;
 
   // Have keys be handled by the views themselves.
   return acc_focused_view_->OnKeyReleased(e);
@@ skipping 57 matching lines @@
                                      l10n_util::GetString(IDS_ZOOM_NORMAL));
   zoom_menu->AppendMenuItemWithLabel(IDC_ZOOM_MINUS,
                                      l10n_util::GetString(IDS_ZOOM_MINUS));
 
   // Create encoding menu.
   views::Menu* encoding_menu = menu->AppendSubMenu(
       IDC_ENCODING_MENU, l10n_util::GetString(IDS_ENCODING_MENU));
 
   EncodingMenuControllerDelegate::BuildEncodingMenu(profile_, encoding_menu);
 
-  struct MenuCreateMaterial {
+#if defined(OS_WIN)
+  const struct MenuCreateMaterial {
     unsigned int menu_id;
     unsigned int menu_label_id;
-  };
-  struct MenuCreateMaterial developer_menu_materials[] = {
+  } developer_menu_materials[] = {
     { IDC_VIEW_SOURCE, IDS_VIEW_SOURCE },
     { IDC_DEBUGGER, IDS_DEBUGGER },
     { IDC_JS_CONSOLE, IDS_JS_CONSOLE },
     { IDC_TASK_MANAGER, IDS_TASK_MANAGER }
   };
   // Append developer menu.
   menu->AppendSeparator();
   views::Menu* developer_menu = menu->AppendSubMenu(IDC_DEVELOPER_MENU,
       l10n_util::GetString(IDS_DEVELOPER_MENU));
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool new_tools = !command_line.HasSwitch(
       switches::kDisableOutOfProcessDevTools);
 
   for (int i = 0; i < arraysize(developer_menu_materials); ++i) {
     if (new_tools && developer_menu_materials[i].menu_id == IDC_DEBUGGER)
       continue;
     if (developer_menu_materials[i].menu_id) {
       developer_menu->AppendMenuItemWithLabel(
           developer_menu_materials[i].menu_id,
           l10n_util::GetString(developer_menu_materials[i].menu_label_id));
     } else {
       developer_menu->AppendSeparator();
     }
   }
+#endif
 
   menu->AppendSeparator();
 
   menu->AppendMenuItemWithLabel(IDC_REPORT_BUG,
                                l10n_util::GetString(IDS_REPORT_BUG));
   menu->RunMenuAt(pt.x(), pt.y());
 }
 
 void BrowserToolbarView::RunAppMenu(const gfx::Point& pt,
                                     gfx::NativeView parent) {
@@ skipping 182 matching lines @@
 }
 
 void BrowserToolbarView::WriteDragData(views::View* sender,
                                        int press_x,
                                        int press_y,
                                        OSExchangeData* data) {
   DCHECK(
       GetDragOperations(sender, press_x, press_y) != DragDropTypes::DRAG_NONE);
 
   UserMetrics::RecordAction(L"Toolbar_DragStar", profile_);
-
+  
+#if defined(OS_WIN)
   // If there is a bookmark for the URL, add the bookmark drag data for it. We
   // do this to ensure the bookmark is moved, rather than creating an new
   // bookmark.
   if (profile_ && profile_->GetBookmarkModel()) {
     BookmarkNode* node = profile_->GetBookmarkModel()->
         GetMostRecentlyAddedNodeForURL(tab_->GetURL());
     if (node) {
       BookmarkDragData bookmark_data(node);
       bookmark_data.Write(profile_, data);
     }
   }
 
   drag_utils::SetURLAndDragImage(tab_->GetURL(),
                                  UTF16ToWideHack(tab_->GetTitle()),
                                  tab_->GetFavIcon(),
                                  data);
+#else
+  // TODO(port): do bookmark item drag & drop
+  NOTIMPLEMENTED();
+#endif
 }
 
 TabContents* BrowserToolbarView::GetTabContents() {
   return tab_;
 }
 
 void BrowserToolbarView::EnabledStateChangedForCommand(int id, bool enabled) {
   views::Button* button = NULL;
   switch (id) {
     case IDC_BACK:
@@ skipping 73 matching lines @@
     case IDC_COPY:
       *accel = views::Accelerator(L'C', false, true, false);
       return true;
     case IDC_PASTE:
       *accel = views::Accelerator(L'V', false, true, false);
       return true;
   }
   // Else, we retrieve the accelerator information from the frame.
   return GetWidget()->GetAccelerator(id, accel);
 }