Rename ShellWindow* classes

chrome/browser/ui/views/extensions/native_app_window_views.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/extensions/shell_window_views.h"
+#include "chrome/browser/ui/views/extensions/native_app_window_views.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/ui/views/extensions/extension_keybinding_registry_views.h"
 #include "chrome/common/extensions/draggable_region.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 35 matching lines @@
 
 // Height of the chrome-style caption, in pixels.
 const int kCaptionHeight = 25;
 }  // namespace
 
 class ShellWindowFrameView : public views::NonClientFrameView,
                              public views::ButtonListener {
  public:
   static const char kViewClassName[];
 
-  explicit ShellWindowFrameView(ShellWindowViews* window);
+  explicit ShellWindowFrameView(NativeAppWindowViews* window);
   virtual ~ShellWindowFrameView();
 
   void Init(views::Widget* frame);
 
   // views::NonClientFrameView implementation.
   virtual gfx::Rect GetBoundsForClientView() const OVERRIDE;
   virtual gfx::Rect GetWindowBoundsForClientBounds(
       const gfx::Rect& client_bounds) const OVERRIDE;
   virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE;
   virtual void GetWindowMask(const gfx::Size& size,
                              gfx::Path* window_mask) OVERRIDE;
   virtual void ResetWindowControls() OVERRIDE {}
   virtual void UpdateWindowIcon() OVERRIDE {}
   virtual void UpdateWindowTitle() OVERRIDE {}
 
   // views::View implementation.
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void Layout() OVERRIDE;
   virtual std::string GetClassName() const OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
   virtual gfx::Size GetMinimumSize() OVERRIDE;
   virtual gfx::Size GetMaximumSize() OVERRIDE;
 
  private:
   // views::ButtonListener implementation.
   virtual void ButtonPressed(views::Button* sender, const ui::Event& event)
       OVERRIDE;
 
-  ShellWindowViews* window_;
+  NativeAppWindowViews* window_;
   views::Widget* frame_;
   views::ImageButton* close_button_;
   views::ImageButton* maximize_button_;
   views::ImageButton* restore_button_;
   views::ImageButton* minimize_button_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellWindowFrameView);
 };
 
 const char ShellWindowFrameView::kViewClassName[] =
     "browser/ui/views/extensions/ShellWindowFrameView";
 
-ShellWindowFrameView::ShellWindowFrameView(ShellWindowViews* window)
+ShellWindowFrameView::ShellWindowFrameView(NativeAppWindowViews* window)
     : window_(window),
       frame_(NULL),
       close_button_(NULL) {
 }
 
 ShellWindowFrameView::~ShellWindowFrameView() {
 }
 
 void ShellWindowFrameView::Init(views::Widget* frame) {
   frame_ = frame;
@@ skipping 274 matching lines @@
   if (sender == close_button_)
     frame_->Close();
   else if (sender == maximize_button_)
     frame_->Maximize();
   else if (sender == restore_button_)
     frame_->Restore();
   else if (sender == minimize_button_)
     frame_->Minimize();
 }
 
-ShellWindowViews::ShellWindowViews(ShellWindow* shell_window,
-                                   const ShellWindow::CreateParams& win_params)
+NativeAppWindowViews::NativeAppWindowViews(
+    ShellWindow* shell_window,
+    const ShellWindow::CreateParams& win_params)
     : shell_window_(shell_window),
       web_view_(NULL),
       is_fullscreen_(false),
       frameless_(win_params.frame == ShellWindow::CreateParams::FRAME_NONE) {
   window_ = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.delegate = this;
   params.remove_standard_frame = true;
   params.use_system_default_icon = true;
   minimum_size_ = win_params.minimum_size;
@@ skipping 20 matching lines @@
   extension_keybinding_registry_.reset(
       new ExtensionKeybindingRegistryViews(shell_window_->profile(),
           window_->GetFocusManager(),
           extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
           shell_window_));
 
   OnViewWasResized();
   window_->AddObserver(this);
 }
 
-views::View* ShellWindowViews::GetInitiallyFocusedView() {
+views::View* NativeAppWindowViews::GetInitiallyFocusedView() {
   return web_view_;
 }
 
-bool ShellWindowViews::ShouldDescendIntoChildForEventHandling(
+bool NativeAppWindowViews::ShouldDescendIntoChildForEventHandling(
     gfx::NativeView child,
     const gfx::Point& location) {
 #if defined(USE_AURA)
   DCHECK_EQ(child, web_view_->web_contents()->GetView()->GetNativeView());
   // Shell window should claim mouse events that fall within the draggable
   // region.
   return !draggable_region_.get() ||
          !draggable_region_->contains(location.x(), location.y());
 #else
   return true;
 #endif
 }
 
-void ShellWindowViews::OnFocus() {
+void NativeAppWindowViews::OnFocus() {
   web_view_->RequestFocus();
 }
 
-void ShellWindowViews::ViewHierarchyChanged(
+void NativeAppWindowViews::ViewHierarchyChanged(
     bool is_add, views::View *parent, views::View *child) {
   if (is_add && child == this) {
     web_view_ = new views::WebView(NULL);
     AddChildView(web_view_);
     web_view_->SetWebContents(web_contents());
   }
 }
 
-gfx::Size ShellWindowViews::GetMinimumSize() {
+gfx::Size NativeAppWindowViews::GetMinimumSize() {
   return minimum_size_;
 }
 
-gfx::Size ShellWindowViews::GetMaximumSize() {
+gfx::Size NativeAppWindowViews::GetMaximumSize() {
   return maximum_size_;
 }
 
-void ShellWindowViews::SetFullscreen(bool fullscreen) {
+void NativeAppWindowViews::SetFullscreen(bool fullscreen) {
   is_fullscreen_ = fullscreen;
   window_->SetFullscreen(fullscreen);
   // 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 ShellWindowViews::IsFullscreenOrPending() const {
+bool NativeAppWindowViews::IsFullscreenOrPending() const {
   return is_fullscreen_;
 }
 
-ShellWindowViews::~ShellWindowViews() {
+NativeAppWindowViews::~NativeAppWindowViews() {
   web_view_->SetWebContents(NULL);
 }
 
-bool ShellWindowViews::IsActive() const {
+bool NativeAppWindowViews::IsActive() const {
   return window_->IsActive();
 }
 
-bool ShellWindowViews::IsMaximized() const {
+bool NativeAppWindowViews::IsMaximized() const {
   return window_->IsMaximized();
 }
 
-bool ShellWindowViews::IsMinimized() const {
+bool NativeAppWindowViews::IsMinimized() const {
   return window_->IsMinimized();
 }
 
-bool ShellWindowViews::IsFullscreen() const {
+bool NativeAppWindowViews::IsFullscreen() const {
   return window_->IsFullscreen();
 }
 
-gfx::NativeWindow ShellWindowViews::GetNativeWindow() {
+gfx::NativeWindow NativeAppWindowViews::GetNativeWindow() {
   return window_->GetNativeWindow();
 }
 
-gfx::Rect ShellWindowViews::GetRestoredBounds() const {
+gfx::Rect NativeAppWindowViews::GetRestoredBounds() const {
   return window_->GetRestoredBounds();
 }
 
-gfx::Rect ShellWindowViews::GetBounds() const {
+gfx::Rect NativeAppWindowViews::GetBounds() const {
   return window_->GetWindowBoundsInScreen();
 }
 
-void ShellWindowViews::Show() {
+void NativeAppWindowViews::Show() {
   if (window_->IsVisible()) {
     window_->Activate();
     return;
   }
 
   window_->Show();
 }
 
-void ShellWindowViews::ShowInactive() {
+void NativeAppWindowViews::ShowInactive() {
   if (window_->IsVisible())
     return;
   window_->ShowInactive();
 }
 
-void ShellWindowViews::Hide() {
+void NativeAppWindowViews::Hide() {
   window_->Hide();
 }
 
-void ShellWindowViews::Close() {
+void NativeAppWindowViews::Close() {
   window_->Close();
 }
 
-void ShellWindowViews::Activate() {
+void NativeAppWindowViews::Activate() {
   window_->Activate();
 }
 
-void ShellWindowViews::Deactivate() {
+void NativeAppWindowViews::Deactivate() {
   window_->Deactivate();
 }
 
-void ShellWindowViews::Maximize() {
+void NativeAppWindowViews::Maximize() {
   window_->Maximize();
 }
 
-void ShellWindowViews::Minimize() {
+void NativeAppWindowViews::Minimize() {
   window_->Minimize();
 }
 
-void ShellWindowViews::Restore() {
+void NativeAppWindowViews::Restore() {
   window_->Restore();
 }
 
-void ShellWindowViews::SetBounds(const gfx::Rect& bounds) {
+void NativeAppWindowViews::SetBounds(const gfx::Rect& bounds) {
   GetWidget()->SetBounds(bounds);
 }
 
-void ShellWindowViews::FlashFrame(bool flash) {
+void NativeAppWindowViews::FlashFrame(bool flash) {
   window_->FlashFrame(flash);
 }
 
-bool ShellWindowViews::IsAlwaysOnTop() const {
+bool NativeAppWindowViews::IsAlwaysOnTop() const {
   return false;
 }
 
-void ShellWindowViews::DeleteDelegate() {
+void NativeAppWindowViews::DeleteDelegate() {
   window_->RemoveObserver(this);
   shell_window_->OnNativeClose();
 }
 
-bool ShellWindowViews::CanResize() const {
+bool NativeAppWindowViews::CanResize() const {
   return maximum_size_.IsEmpty() || minimum_size_ != maximum_size_;
 }
 
-bool ShellWindowViews::CanMaximize() const {
+bool NativeAppWindowViews::CanMaximize() const {
   return maximum_size_.IsEmpty();
 }
 
-views::View* ShellWindowViews::GetContentsView() {
+views::View* NativeAppWindowViews::GetContentsView() {
   return this;
 }
 
-views::NonClientFrameView* ShellWindowViews::CreateNonClientFrameView(
+views::NonClientFrameView* NativeAppWindowViews::CreateNonClientFrameView(
     views::Widget* widget) {
 #if defined(USE_ASH)
   if (chrome::IsNativeViewInAsh(widget->GetNativeView()) && !frameless_) {
     ash::CustomFrameViewAsh* frame = new ash::CustomFrameViewAsh();
     frame->Init(widget);
     return frame;
   }
 #endif
   ShellWindowFrameView* frame_view = new ShellWindowFrameView(this);
   frame_view->Init(window_);
   return frame_view;
 }
 
-string16 ShellWindowViews::GetWindowTitle() const {
+string16 NativeAppWindowViews::GetWindowTitle() const {
   return shell_window_->GetTitle();
 }
 
-views::Widget* ShellWindowViews::GetWidget() {
+views::Widget* NativeAppWindowViews::GetWidget() {
   return window_;
 }
 
-const views::Widget* ShellWindowViews::GetWidget() const {
+const views::Widget* NativeAppWindowViews::GetWidget() const {
   return window_;
 }
 
-void ShellWindowViews::OnViewWasResized() {
+void NativeAppWindowViews::OnViewWasResized() {
   // TODO(jeremya): this doesn't seem like a terribly elegant way to keep the
   // window shape in sync.
 #if defined(OS_WIN) && !defined(USE_AURA)
   // Set the window shape of the RWHV.
   DCHECK(window_);
   DCHECK(web_view_);
   gfx::Size sz = web_view_->size();
   int height = sz.height(), width = sz.width();
   int radius = 1;
   gfx::Path path;
@@ skipping 31 matching lines @@
           SkRegion::kUnion_Op);
       rgn->op(0, height - kResizeInsideBoundsSize, width, height,
           SkRegion::kUnion_Op);
     }
   }
   if (web_contents()->GetRenderViewHost()->GetView())
     web_contents()->GetRenderViewHost()->GetView()->SetClickthroughRegion(rgn);
 #endif
 }
 
-gfx::ImageSkia ShellWindowViews::GetWindowAppIcon() {
+gfx::ImageSkia NativeAppWindowViews::GetWindowAppIcon() {
   gfx::Image app_icon = shell_window_->app_icon();
   if (app_icon.IsEmpty())
     return GetWindowIcon();
   else
     return *app_icon.ToImageSkia();
 }
 
-gfx::ImageSkia ShellWindowViews::GetWindowIcon() {
+gfx::ImageSkia NativeAppWindowViews::GetWindowIcon() {
   content::WebContents* web_contents = shell_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();
 }
 
-bool ShellWindowViews::ShouldShowWindowTitle() const {
+bool NativeAppWindowViews::ShouldShowWindowTitle() const {
   return false;
 }
 
-void ShellWindowViews::OnWidgetMove() {
+void NativeAppWindowViews::OnWidgetMove() {
   shell_window_->OnNativeWindowChanged();
 }
 
-void ShellWindowViews::OnWidgetVisibilityChanged(views::Widget* widget,
-                                                 bool visible) {
+void NativeAppWindowViews::OnWidgetVisibilityChanged(views::Widget* widget,
+                                                     bool visible) {
   shell_window_->OnNativeWindowChanged();
 }
 
-void ShellWindowViews::OnWidgetActivationChanged(views::Widget* widget,
-                                                 bool active) {
+void NativeAppWindowViews::OnWidgetActivationChanged(views::Widget* widget,
+                                                     bool active) {
   shell_window_->OnNativeWindowChanged();
 }
 
-void ShellWindowViews::Layout() {
+void NativeAppWindowViews::Layout() {
   DCHECK(web_view_);
   web_view_->SetBounds(0, 0, width(), height());
   OnViewWasResized();
 }
 
-void ShellWindowViews::UpdateWindowIcon() {
+void NativeAppWindowViews::UpdateWindowIcon() {
   window_->UpdateWindowIcon();
 }
 
-void ShellWindowViews::UpdateWindowTitle() {
+void NativeAppWindowViews::UpdateWindowTitle() {
   window_->UpdateWindowTitle();
 }
 
-void ShellWindowViews::UpdateDraggableRegions(
+void NativeAppWindowViews::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
   if (!frameless_)
     return;
 
   draggable_region_.reset(ShellWindow::RawDraggableRegionsToSkRegion(regions));
   OnViewWasResized();
 }
 
-void ShellWindowViews::HandleKeyboardEvent(
+void NativeAppWindowViews::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   unhandled_keyboard_event_handler_.HandleKeyboardEvent(event,
                                                         GetFocusManager());
 }
 
-void ShellWindowViews::RenderViewHostChanged() {
+void NativeAppWindowViews::RenderViewHostChanged() {
   OnViewWasResized();
 }
 
-void ShellWindowViews::SaveWindowPlacement(const gfx::Rect& bounds,
-                                           ui::WindowShowState show_state) {
+void NativeAppWindowViews::SaveWindowPlacement(const gfx::Rect& bounds,
+                                               ui::WindowShowState show_state) {
   views::WidgetDelegate::SaveWindowPlacement(bounds, show_state);
   shell_window_->OnNativeWindowChanged();
 }
 
 // static
-NativeShellWindow* NativeShellWindow::Create(
+NativeAppWindow* NativeAppWindow::Create(
     ShellWindow* shell_window, const ShellWindow::CreateParams& params) {
-  return new ShellWindowViews(shell_window, params);
+  return new NativeAppWindowViews(shell_window, params);
 }