Rename BaseNativeAppWindowViews and NativeAppWindowViews

chrome/browser/ui/views/apps/chrome_native_app_window_views.cc

 // Copyright 2013 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/apps/native_app_window_views.h"
+#include "chrome/browser/ui/views/apps/chrome_native_app_window_views.h"
 
 #include "apps/ui/views/app_window_frame_view.h"
 #include "base/command_line.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/chrome_page_zoom.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/views/apps/shaped_app_window_targeter.h"
@@ skipping 168 matching lines @@
   // Not owned.
   AppWindow* app_window_;
   ash::wm::WindowState* window_state_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeAppWindowStateDelegate);
 };
 #endif  // USE_ASH
 
 }  // namespace
 
-NativeAppWindowViews::NativeAppWindowViews()
+ChromeNativeAppWindowViews::ChromeNativeAppWindowViews()
     : is_fullscreen_(false),
       has_frame_color_(false),
       frame_color_(SK_ColorBLACK) {}
 
-NativeAppWindowViews::~NativeAppWindowViews() {}
+ChromeNativeAppWindowViews::~ChromeNativeAppWindowViews() {}
 
-void NativeAppWindowViews::OnBeforeWidgetInit(
+void ChromeNativeAppWindowViews::OnBeforeWidgetInit(
     views::Widget::InitParams* init_params,
     views::Widget* widget) {}
 
-void NativeAppWindowViews::InitializeDefaultWindow(
+void ChromeNativeAppWindowViews::InitializeDefaultWindow(
     const AppWindow::CreateParams& create_params) {
   std::string app_name =
       web_app::GenerateApplicationNameFromExtensionId(
           app_window()->extension()->id());
 
   views::Widget::InitParams init_params(views::Widget::InitParams::TYPE_WINDOW);
   init_params.delegate = this;
   init_params.remove_standard_frame = !ShouldUseNativeFrame();
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // On Linux, remove the standard frame. Instead, we will use CustomFrameView
@@ skipping 55 matching lines @@
            accelerator_table.begin();
        iter != accelerator_table.end(); ++iter) {
     if (is_kiosk_app_mode && !chrome::IsCommandAllowedInAppMode(iter->second))
       continue;
 
     focus_manager->RegisterAccelerator(
         iter->first, ui::AcceleratorManager::kNormalPriority, this);
   }
 }
 
-void NativeAppWindowViews::InitializePanelWindow(
+void ChromeNativeAppWindowViews::InitializePanelWindow(
     const AppWindow::CreateParams& create_params) {
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_PANEL);
   params.delegate = this;
 
   preferred_size_ = gfx::Size(create_params.bounds.width(),
                               create_params.bounds.height());
   if (preferred_size_.width() == 0)
     preferred_size_.set_width(kDefaultPanelWidth);
   else if (preferred_size_.width() < kMinPanelWidth)
     preferred_size_.set_width(kMinPanelWidth);
@@ skipping 32 matching lines @@
                                           native_window->GetRootWindow(),
                                           native_window->GetBoundsInScreen());
     window()->SetBounds(window_bounds);
   }
 #else
   // TODO(stevenjb): NativeAppWindow panels need to be implemented for other
   // platforms.
 #endif
 }
 
-bool NativeAppWindowViews::ShouldUseNativeFrame() const {
+bool ChromeNativeAppWindowViews::ShouldUseNativeFrame() const {
   return !IsFrameless() & !has_frame_color_;
 }
 
-void NativeAppWindowViews::InstallEasyResizeTargeterOnContainer() const {
+void ChromeNativeAppWindowViews::InstallEasyResizeTargeterOnContainer() const {
   aura::Window* root_window = window()->GetNativeWindow()->GetRootWindow();
   gfx::Insets inset(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
                     kResizeInsideBoundsSize, kResizeInsideBoundsSize);
   root_window->SetEventTargeter(scoped_ptr<ui::EventTargeter>(
       new wm::EasyResizeWindowTargeter(root_window, inset, inset)));
 }
 
 apps::AppWindowFrameView*
-NativeAppWindowViews::CreateAppWindowFrameView() {
+ChromeNativeAppWindowViews::CreateAppWindowFrameView() {
   // By default the user can resize the window from slightly inside the bounds.
   int resize_inside_bounds_size = kResizeInsideBoundsSize;
   int resize_outside_bounds_size = 0;
   int resize_outside_scale_for_touch = 1;
   int resize_area_corner_size = kResizeAreaCornerSize;
 #if defined(USE_ASH)
   // For Aura windows on the Ash desktop the sizes are different and the user
   // can resize the window from slightly outside the bounds as well.
   if (chrome::IsNativeWindowInAsh(window()->GetNativeWindow())) {
     resize_inside_bounds_size = ash::kResizeInsideBoundsSize;
     resize_outside_bounds_size = ash::kResizeOutsideBoundsSize;
     resize_outside_scale_for_touch = ash::kResizeOutsideBoundsScaleForTouch;
     resize_area_corner_size = ash::kResizeAreaCornerSize;
   }
 #endif
   apps::AppWindowFrameView* frame_view = new apps::AppWindowFrameView(this);
   frame_view->Init(window(),
                    frame_color_,
                    resize_inside_bounds_size,
                    resize_outside_bounds_size,
                    resize_outside_scale_for_touch,
                    resize_area_corner_size);
   return frame_view;
 }
 
 // ui::BaseWindow implementation.
 
-ui::WindowShowState NativeAppWindowViews::GetRestoredState() const {
+ui::WindowShowState ChromeNativeAppWindowViews::GetRestoredState() const {
   if (IsMaximized())
     return ui::SHOW_STATE_MAXIMIZED;
   if (IsFullscreen()) {
 #if defined(USE_ASH)
     if (immersive_fullscreen_controller_.get() &&
         immersive_fullscreen_controller_->IsEnabled()) {
       // Restore windows which were previously in immersive fullscreen to
       // maximized. Restoring the window to a different fullscreen type
       // makes for a bad experience.
       return ui::SHOW_STATE_MAXIMIZED;
@@ skipping 18 matching lines @@
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_MINIMIZED:
     case ui::SHOW_STATE_INACTIVE:
     case ui::SHOW_STATE_END:
       return ui::SHOW_STATE_NORMAL;
   }
 #endif
   return ui::SHOW_STATE_NORMAL;
 }
 
-bool NativeAppWindowViews::IsAlwaysOnTop() const {
+bool ChromeNativeAppWindowViews::IsAlwaysOnTop() const {
   if (app_window()->window_type_is_panel()) {
 #if defined(USE_ASH)
     return ash::wm::GetWindowState(window()->GetNativeWindow())->
         panel_attached();
 #else
     return true;
 #endif
   } else {
     return window()->IsAlwaysOnTop();
   }
 }
 
 // views::ContextMenuController implementation.
 
-void NativeAppWindowViews::ShowContextMenuForView(
+void ChromeNativeAppWindowViews::ShowContextMenuForView(
     views::View* source,
     const gfx::Point& p,
     ui::MenuSourceType source_type) {
 #if defined(USE_ASH) && defined(OS_CHROMEOS)
   scoped_ptr<ui::MenuModel> model =
       CreateMultiUserContextMenu(app_window()->GetNativeWindow());
   if (!model.get())
     return;
 
   // Only show context menu if point is in caption.
   gfx::Point point_in_view_coords(p);
   views::View::ConvertPointFromScreen(window()->non_client_view(),
                                       &point_in_view_coords);
   int hit_test = window()->non_client_view()->NonClientHitTest(
       point_in_view_coords);
   if (hit_test == HTCAPTION) {
     menu_runner_.reset(new views::MenuRunner(model.get()));
     if (menu_runner_->RunMenuAt(source->GetWidget(), NULL,
           gfx::Rect(p, gfx::Size(0,0)), views::MenuItemView::TOPLEFT,
           source_type,
           views::MenuRunner::HAS_MNEMONICS | views::MenuRunner::CONTEXT_MENU) ==
         views::MenuRunner::MENU_DELETED)
       return;
   }
 #endif
 }
 
 // views::WidgetDelegate implementation.
 
-gfx::ImageSkia NativeAppWindowViews::GetWindowAppIcon() {
+gfx::ImageSkia ChromeNativeAppWindowViews::GetWindowAppIcon() {
   gfx::Image app_icon = app_window()->app_icon();
   if (app_icon.IsEmpty())
     return GetWindowIcon();
   else
     return *app_icon.ToImageSkia();
 }
 
-gfx::ImageSkia NativeAppWindowViews::GetWindowIcon() {
+gfx::ImageSkia ChromeNativeAppWindowViews::GetWindowIcon() {
   content::WebContents* web_contents = app_window()->web_contents();
   if (web_contents) {
     FaviconTabHelper* favicon_tab_helper =
         FaviconTabHelper::FromWebContents(web_contents);
     gfx::Image app_icon = favicon_tab_helper->GetFavicon();
     if (!app_icon.IsEmpty())
       return *app_icon.ToImageSkia();
   }
   return gfx::ImageSkia();
 }
 
-views::NonClientFrameView* NativeAppWindowViews::CreateNonClientFrameView(
+views::NonClientFrameView* ChromeNativeAppWindowViews::CreateNonClientFrameView(
     views::Widget* widget) {
 #if defined(USE_ASH)
   if (chrome::IsNativeViewInAsh(widget->GetNativeView())) {
     // Set the delegate now because CustomFrameViewAsh sets the
     // WindowStateDelegate if one is not already set.
     ash::wm::GetWindowState(GetNativeWindow())->SetDelegate(
         scoped_ptr<ash::wm::WindowStateDelegate>(
             new NativeAppWindowStateDelegate(app_window(), this)).Pass());
 
     if (app_window()->window_type_is_panel()) {
@@ skipping 22 matching lines @@
       custom_frame_view->GetHeaderView()->set_context_menu_controller(this);
       return custom_frame_view;
     }
   }
 #endif
   if (!ShouldUseNativeFrame())
     return CreateAppWindowFrameView();
   return views::WidgetDelegateView::CreateNonClientFrameView(widget);
 }
 
-bool NativeAppWindowViews::WidgetHasHitTestMask() const {
+bool ChromeNativeAppWindowViews::WidgetHasHitTestMask() const {
   return shape_ != NULL;
 }
 
-void NativeAppWindowViews::GetWidgetHitTestMask(gfx::Path* mask) const {
+void ChromeNativeAppWindowViews::GetWidgetHitTestMask(gfx::Path* mask) const {
   shape_->getBoundaryPath(mask);
 }
 
 // views::View implementation.
 
-gfx::Size NativeAppWindowViews::GetPreferredSize() {
+gfx::Size ChromeNativeAppWindowViews::GetPreferredSize() {
   if (!preferred_size_.IsEmpty())
     return preferred_size_;
-  return BaseNativeAppWindowViews::GetPreferredSize();
+  return NativeAppWindowViews::GetPreferredSize();
 }
 
-bool NativeAppWindowViews::AcceleratorPressed(
+bool ChromeNativeAppWindowViews::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
   const std::map<ui::Accelerator, int>& accelerator_table =
       GetAcceleratorTable();
   std::map<ui::Accelerator, int>::const_iterator iter =
       accelerator_table.find(accelerator);
   DCHECK(iter != accelerator_table.end());
   int command_id = iter->second;
   switch (command_id) {
     case IDC_CLOSE_WINDOW:
       Close();
       return true;
     case IDC_ZOOM_MINUS:
       chrome_page_zoom::Zoom(web_view()->GetWebContents(),
                              content::PAGE_ZOOM_OUT);
       return true;
     case IDC_ZOOM_NORMAL:
       chrome_page_zoom::Zoom(web_view()->GetWebContents(),
                              content::PAGE_ZOOM_RESET);
       return true;
     case IDC_ZOOM_PLUS:
       chrome_page_zoom::Zoom(web_view()->GetWebContents(),
                              content::PAGE_ZOOM_IN);
       return true;
     default:
       NOTREACHED() << "Unknown accelerator sent to app window.";
   }
-  return BaseNativeAppWindowViews::AcceleratorPressed(accelerator);
+  return NativeAppWindowViews::AcceleratorPressed(accelerator);
 }
 
 // NativeAppWindow implementation.
 
-void NativeAppWindowViews::SetFullscreen(int fullscreen_types) {
+void ChromeNativeAppWindowViews::SetFullscreen(int fullscreen_types) {
   // Fullscreen not supported by panels.
   if (app_window()->window_type_is_panel())
     return;
   is_fullscreen_ = (fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
   window()->SetFullscreen(is_fullscreen_);
 
 #if defined(USE_ASH)
   if (immersive_fullscreen_controller_.get()) {
     // |immersive_fullscreen_controller_| should only be set if immersive
     // fullscreen is the fullscreen type used by the OS.
     immersive_fullscreen_controller_->SetEnabled(
         ash::ImmersiveFullscreenController::WINDOW_TYPE_PACKAGED_APP,
         (fullscreen_types & AppWindow::FULLSCREEN_TYPE_OS) != 0);
     // Autohide the shelf instead of hiding the shelf completely when only in
     // OS fullscreen.
     ash::wm::WindowState* window_state =
         ash::wm::GetWindowState(window()->GetNativeWindow());
     window_state->set_hide_shelf_when_fullscreen(fullscreen_types !=
                                                  AppWindow::FULLSCREEN_TYPE_OS);
     DCHECK(ash::Shell::HasInstance());
     ash::Shell::GetInstance()->UpdateShelfVisibility();
   }
 #endif
 
   // TODO(jeremya) we need to call RenderViewHost::ExitFullscreen() if we
   // ever drop the window out of fullscreen in response to something that
   // wasn't the app calling webkitCancelFullScreen().
 }
 
-bool NativeAppWindowViews::IsFullscreenOrPending() const {
+bool ChromeNativeAppWindowViews::IsFullscreenOrPending() const {
   return is_fullscreen_;
 }
 
-bool NativeAppWindowViews::IsDetached() const {
+bool ChromeNativeAppWindowViews::IsDetached() const {
   if (!app_window()->window_type_is_panel())
     return false;
 #if defined(USE_ASH)
   return !ash::wm::GetWindowState(window()->GetNativeWindow())
               ->panel_attached();
 #else
   return false;
 #endif
 }
 
-void NativeAppWindowViews::UpdateBadgeIcon() {
+void ChromeNativeAppWindowViews::UpdateBadgeIcon() {
   const gfx::Image* icon = NULL;
   if (!app_window()->badge_icon().IsEmpty()) {
     icon = &app_window()->badge_icon();
     // chrome::DrawTaskbarDecoration can do interesting things with non-square
     // bitmaps.
     // TODO(benwells): Refactor chrome::DrawTaskbarDecoration to not be avatar
     // specific, and lift this restriction.
     if (icon->Width() != icon->Height()) {
       LOG(ERROR) << "Attempt to set a non-square badge; request ignored.";
       return;
     }
   }
   chrome::DrawTaskbarDecoration(GetNativeWindow(), icon);
 }
 
-void NativeAppWindowViews::UpdateShape(scoped_ptr<SkRegion> region) {
+void ChromeNativeAppWindowViews::UpdateShape(scoped_ptr<SkRegion> region) {
   bool had_shape = shape_;
   shape_ = region.Pass();
 
   aura::Window* native_window = window()->GetNativeWindow();
   if (shape_) {
     window()->SetShape(new SkRegion(*shape_));
     if (!had_shape) {
       native_window->SetEventTargeter(scoped_ptr<ui::EventTargeter>(
           new ShapedAppWindowTargeter(native_window, this)));
     }
   } else {
     window()->SetShape(NULL);
     if (had_shape)
       native_window->SetEventTargeter(scoped_ptr<ui::EventTargeter>());
   }
 }
 
-bool NativeAppWindowViews::HasFrameColor() const {
+bool ChromeNativeAppWindowViews::HasFrameColor() const {
   return has_frame_color_;
 }
 
-SkColor NativeAppWindowViews::FrameColor() const { return frame_color_; }
+SkColor ChromeNativeAppWindowViews::FrameColor() const { return frame_color_; }
 
-// BaseNativeAppWindowViews implementation.
+// NativeAppWindowViews implementation.
 
-void NativeAppWindowViews::InitializeWindow(
+void ChromeNativeAppWindowViews::InitializeWindow(
     AppWindow* app_window,
     const AppWindow::CreateParams& create_params) {
   DCHECK(window());
   has_frame_color_ = create_params.has_frame_color;
   frame_color_ = create_params.frame_color;
   if (create_params.window_type == AppWindow::WINDOW_TYPE_PANEL ||
       create_params.window_type == AppWindow::WINDOW_TYPE_V1_PANEL) {
     InitializePanelWindow(create_params);
   } else {
     InitializeDefaultWindow(create_params);
   }
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryViews(
       Profile::FromBrowserContext(app_window->browser_context()),
       window()->GetFocusManager(),
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
       app_window));
 
 #if defined(OS_WIN)
   if (ShouldUseNativeFrame() &&
       chrome::GetHostDesktopTypeForNativeWindow(window()->GetNativeWindow()) !=
       chrome::HOST_DESKTOP_TYPE_ASH) {
     InstallEasyResizeTargeterOnContainer();
   }
 #endif
 }