Reenable most panel interactive_ui_tests on Linux

chrome/browser/ui/views/panels/panel_view.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/panels/panel_view.h"
 
 #include <map>
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 80 matching lines @@
     for (size_t i = 0; i < arraysize(kPanelAcceleratorMap); ++i) {
       ui::Accelerator accelerator(kPanelAcceleratorMap[i].keycode,
                                   kPanelAcceleratorMap[i].modifiers);
       (*accelerators)[accelerator] = kPanelAcceleratorMap[i].command_id;
     }
   }
   return *accelerators;
 }
 
 // NativePanelTesting implementation.
-class NativePanelTestingWin : public NativePanelTesting {
+class NativePanelTestingViews : public NativePanelTesting {
  public:
-  explicit NativePanelTestingWin(PanelView* panel_view);
+  explicit NativePanelTestingViews(PanelView* panel_view);
+  virtual ~NativePanelTestingViews();
 
  private:
   virtual void PressLeftMouseButtonTitlebar(
       const gfx::Point& mouse_location, panel::ClickModifier modifier) OVERRIDE;
   virtual void ReleaseMouseButtonTitlebar(
       panel::ClickModifier modifier) OVERRIDE;
   virtual void DragTitlebar(const gfx::Point& mouse_location) OVERRIDE;
   virtual void CancelDragTitlebar() OVERRIDE;
   virtual void FinishDragTitlebar() OVERRIDE;
   virtual bool VerifyDrawingAttention() const OVERRIDE;
   virtual bool VerifyActiveState(bool is_active) OVERRIDE;
   virtual bool VerifyAppIcon() const OVERRIDE;
   virtual bool VerifySystemMinimizeState() const OVERRIDE;
   virtual bool IsWindowVisible() const OVERRIDE;
   virtual bool IsWindowSizeKnown() const OVERRIDE;
   virtual bool IsAnimatingBounds() const OVERRIDE;
   virtual bool IsButtonVisible(
       panel::TitlebarButtonType button_type) const OVERRIDE;
   virtual panel::CornerStyle GetWindowCornerStyle() const OVERRIDE;
   virtual bool EnsureApplicationRunOnForeground() OVERRIDE;
 
   PanelView* panel_view_;
 };
 
-NativePanelTestingWin::NativePanelTestingWin(PanelView* panel_view)
+NativePanelTestingViews::NativePanelTestingViews(PanelView* panel_view)
     : panel_view_(panel_view) {
 }
 
-void NativePanelTestingWin::PressLeftMouseButtonTitlebar(
+NativePanelTestingViews::~NativePanelTestingViews() {
+}
+
+void NativePanelTestingViews::PressLeftMouseButtonTitlebar(
     const gfx::Point& mouse_location, panel::ClickModifier modifier) {
   panel_view_->OnTitlebarMousePressed(mouse_location);
 }
 
-void NativePanelTestingWin::ReleaseMouseButtonTitlebar(
+void NativePanelTestingViews::ReleaseMouseButtonTitlebar(
     panel::ClickModifier modifier) {
   panel_view_->OnTitlebarMouseReleased(modifier);
 }
 
-void NativePanelTestingWin::DragTitlebar(const gfx::Point& mouse_location) {
+void NativePanelTestingViews::DragTitlebar(const gfx::Point& mouse_location) {
   panel_view_->OnTitlebarMouseDragged(mouse_location);
 }
 
-void NativePanelTestingWin::CancelDragTitlebar() {
+void NativePanelTestingViews::CancelDragTitlebar() {
   panel_view_->OnTitlebarMouseCaptureLost();
 }
 
-void NativePanelTestingWin::FinishDragTitlebar() {
+void NativePanelTestingViews::FinishDragTitlebar() {
   panel_view_->OnTitlebarMouseReleased(panel::NO_MODIFIER);
 }
 
-bool NativePanelTestingWin::VerifyDrawingAttention() const {
+bool NativePanelTestingViews::VerifyDrawingAttention() const {
   base::MessageLoop::current()->RunUntilIdle();
   return panel_view_->GetFrameView()->GetPaintState() ==
          PanelFrameView::PAINT_FOR_ATTENTION;
 }
 
-bool NativePanelTestingWin::VerifyActiveState(bool is_active) {
+bool NativePanelTestingViews::VerifyActiveState(bool is_active) {
   return panel_view_->GetFrameView()->GetPaintState() ==
          (is_active ? PanelFrameView::PAINT_AS_ACTIVE
                     : PanelFrameView::PAINT_AS_INACTIVE);
 }
 
-bool NativePanelTestingWin::VerifyAppIcon() const {
+bool NativePanelTestingViews::VerifyAppIcon() const {
 #if defined(OS_WIN)
   // We only care about Windows 7 and later.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return true;
 
   HWND native_window = views::HWNDForWidget(panel_view_->window());
   HICON app_icon = reinterpret_cast<HICON>(
       ::SendMessage(native_window, WM_GETICON, ICON_BIG, 0L));
   if (!app_icon)
     return false;
   scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(app_icon));
   return bitmap.get() &&
          bitmap->width() == panel::kPanelAppIconSize &&
          bitmap->height() == panel::kPanelAppIconSize;
 #else
   return true;
 #endif
 }
 
-bool NativePanelTestingWin::VerifySystemMinimizeState() const {
+bool NativePanelTestingViews::VerifySystemMinimizeState() const {
 #if defined(OS_WIN)
   HWND native_window = views::HWNDForWidget(panel_view_->window());
   WINDOWPLACEMENT placement;
   if (!::GetWindowPlacement(native_window, &placement))
     return false;
   if (placement.showCmd == SW_MINIMIZE || placement.showCmd == SW_SHOWMINIMIZED)
     return true;
 
   // If the panel window has owner window, as in stacked mode, check its owner
   // window. Note that owner window, instead of parent window, is returned
   // though GWL_HWNDPARENT contains 'parent'.
   HWND owner_window =
       reinterpret_cast<HWND>(::GetWindowLongPtr(native_window,
                                                 GWLP_HWNDPARENT));
   if (!owner_window || !::GetWindowPlacement(owner_window, &placement))
     return false;
   return placement.showCmd == SW_MINIMIZE ||
          placement.showCmd == SW_SHOWMINIMIZED;
 #else
   return true;
 #endif
 }
 
-bool NativePanelTestingWin::IsWindowVisible() const {
-#if defined(OS_WIN)
-  HWND native_window = views::HWNDForWidget(panel_view_->window());
-  return ::IsWindowVisible(native_window) == TRUE;
-#else
-  return panel_view_->visible();
-#endif
+bool NativePanelTestingViews::IsWindowVisible() const {
+  return panel_view_->window()->IsVisible();
 }
 
-bool NativePanelTestingWin::IsWindowSizeKnown() const {
+bool NativePanelTestingViews::IsWindowSizeKnown() const {
   return true;
 }
 
-bool NativePanelTestingWin::IsAnimatingBounds() const {
+bool NativePanelTestingViews::IsAnimatingBounds() const {
   return panel_view_->IsAnimatingBounds();
 }
 
-bool NativePanelTestingWin::IsButtonVisible(
+bool NativePanelTestingViews::IsButtonVisible(
     panel::TitlebarButtonType button_type) const {
   PanelFrameView* frame_view = panel_view_->GetFrameView();
 
   switch (button_type) {
     case panel::CLOSE_BUTTON:
       return frame_view->close_button()->visible();
     case panel::MINIMIZE_BUTTON:
       return frame_view->minimize_button()->visible();
     case panel::RESTORE_BUTTON:
       return frame_view->restore_button()->visible();
     default:
       NOTREACHED();
   }
   return false;
 }
 
-panel::CornerStyle NativePanelTestingWin::GetWindowCornerStyle() const {
+panel::CornerStyle NativePanelTestingViews::GetWindowCornerStyle() const {
   return panel_view_->GetFrameView()->corner_style();
 }
 
-bool NativePanelTestingWin::EnsureApplicationRunOnForeground() {
+bool NativePanelTestingViews::EnsureApplicationRunOnForeground() {
   // Not needed on views.
   return true;
 }
 
 }  // namespace
 
 // static
 NativePanel* Panel::CreateNativePanel(Panel* panel,
                                       const gfx::Rect& bounds,
                                       bool always_on_top) {
@@ skipping 487 matching lines @@
 
 void PanelView::AttachWebContents(content::WebContents* contents) {
   web_view_->SetWebContents(contents);
 }
 
 void PanelView::DetachWebContents(content::WebContents* contents) {
   web_view_->SetWebContents(NULL);
 }
 
 NativePanelTesting* PanelView::CreateNativePanelTesting() {
-  return new NativePanelTestingWin(this);
+  return new NativePanelTestingViews(this);
 }
 
 void PanelView::OnDisplayChanged() {
   panel_->manager()->display_settings_provider()->OnDisplaySettingsChanged();
 }
 
 void PanelView::OnWorkAreaChanged() {
   panel_->manager()->display_settings_provider()->OnDisplaySettingsChanged();
 }
 
@@ skipping 218 matching lines @@
     return;
 
   bool focused = active;
   if (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_NATIVE) {
     // The panel window is in focus (actually accepting keystrokes) if it is
     // active and belongs to a foreground application.
     focused = active &&
         views::HWNDForWidget(widget) == ::GetForegroundWindow();
   }
 #else
-  NOTIMPLEMENTED();
   bool focused = active;
 #endif
 
   if (focused_ == focused)
     return;
   focused_ = focused;
 
   // Expand the panel if the minimized panel is activated by means other than
   // clicking on its titlebar. This is the workaround to support restoring the
   // minimized panel by other means, like alt-tabbing, win-tabbing, or clicking
@@ skipping 146 matching lines @@
   // SWP_FRAMECHANGED flag must be called in order for the cached window data
   // to be updated properly.
   // http://msdn.microsoft.com/en-us/library/windows/desktop/ms633591(v=vs.85).aspx
   if (update_frame) {
     ::SetWindowPos(native_window, NULL, 0, 0, 0, 0,
                    SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE |
                        SWP_NOZORDER | SWP_NOACTIVATE);
   }
 }
 #endif