Rename ShellWindow* classes

chrome/browser/ui/cocoa/extensions/native_app_window_cocoa.mm

 // 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/cocoa/extensions/shell_window_cocoa.h"
+#include "chrome/browser/ui/cocoa/extensions/native_app_window_cocoa.h"
 
 #include "base/mac/mac_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/cocoa/browser_window_utils.h"
 #import "chrome/browser/ui/cocoa/chrome_event_processing_window.h"
 #include "chrome/browser/ui/cocoa/extensions/extension_keybinding_registry_cocoa.h"
 #include "chrome/browser/ui/cocoa/extensions/extension_view_mac.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 10 matching lines @@
 // Replicate specific 10.7 SDK declarations for building with prior SDKs.
 #if !defined(MAC_OS_X_VERSION_10_7) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
 
 @interface NSWindow (LionSDKDeclarations)
 - (void)toggleFullScreen:(id)sender;
 @end
 
 #endif  // MAC_OS_X_VERSION_10_7
 
-@implementation ShellWindowController
+@implementation NativeAppWindowController
 
-@synthesize shellWindow = shellWindow_;
+@synthesize appWindow = appWindow_;
 
 - (void)windowWillClose:(NSNotification*)notification {
-  if (shellWindow_)
-    shellWindow_->WindowWillClose();
+  if (appWindow_)
+    appWindow_->WindowWillClose();
 }
 
 - (void)windowDidBecomeKey:(NSNotification*)notification {
-  if (shellWindow_)
-    shellWindow_->WindowDidBecomeKey();
+  if (appWindow_)
+    appWindow_->WindowDidBecomeKey();
 }
 
 - (void)windowDidResignKey:(NSNotification*)notification {
-  if (shellWindow_)
-    shellWindow_->WindowDidResignKey();
+  if (appWindow_)
+    appWindow_->WindowDidResignKey();
 }
 
 - (void)windowDidResize:(NSNotification*)notification {
-  if (shellWindow_)
-    shellWindow_->WindowDidResize();
+  if (appWindow_)
+    appWindow_->WindowDidResize();
 }
 
 - (void)windowDidMove:(NSNotification*)notification {
-  if (shellWindow_)
-    shellWindow_->WindowDidMove();
+  if (appWindow_)
+    appWindow_->WindowDidMove();
 }
 
 - (void)gtm_systemRequestsVisibilityForView:(NSView*)view {
   [[self window] makeKeyAndOrderFront:self];
 }
 
 - (GTMWindowSheetController*)sheetController {
   if (!sheetController_.get()) {
     sheetController_.reset([[GTMWindowSheetController alloc]
         initWithWindow:[self window]
               delegate:self]);
   }
   return sheetController_;
 }
 
 - (void)executeCommand:(int)command {
   // No-op, swallow the event.
 }
 
 - (BOOL)handledByExtensionCommand:(NSEvent*)event {
-  if (shellWindow_)
-    return shellWindow_->HandledByExtensionCommand(event);
+  if (appWindow_)
+    return appWindow_->HandledByExtensionCommand(event);
   return NO;
 }
 
 @end
 
 // This is really a method on NSGrayFrame, so it should only be called on the
 // view passed into -[NSWindow drawCustomFrameRect:forView:].
 @interface NSView (PrivateMethods)
 - (CGFloat)roundedCornerRadius;
 @end
@@ skipping 45 matching lines @@
 }
 
 - (NSRect)contentRectForFrameRect:(NSRect)frameRect {
   return frameRect;
 }
 
 @end
 
 @interface ControlRegionView : NSView {
  @private
-  ShellWindowCocoa* shellWindow_;  // Weak; owns self.
+  NativeAppWindowCocoa* appWindow_;  // Weak; owns self.
 }
 
 @end
 
 @implementation ControlRegionView
 
-- (id)initWithShellWindow:(ShellWindowCocoa*)shellWindow {
+- (id)initWithAppWindow:(NativeAppWindowCocoa*)appWindow {
   if ((self = [super init]))
-    shellWindow_ = shellWindow;
+    appWindow_ = appWindow;
   return self;
 }
 
 - (BOOL)mouseDownCanMoveWindow {
   return NO;
 }
 
 - (NSView*)hitTest:(NSPoint)aPoint {
-  if (shellWindow_->use_system_drag() ||
-      !shellWindow_->IsWithinDraggableRegion(aPoint)) {
+  if (appWindow_->use_system_drag() ||
+      !appWindow_->IsWithinDraggableRegion(aPoint)) {
     return nil;
   }
   return self;
 }
 
 - (void)mouseDown:(NSEvent*)event {
-  shellWindow_->HandleMouseEvent(event);
+  appWindow_->HandleMouseEvent(event);
 }
 
 - (void)mouseDragged:(NSEvent*)event {
-  shellWindow_->HandleMouseEvent(event);
+  appWindow_->HandleMouseEvent(event);
 }
 
 @end
 
 @interface NSView (WebContentsView)
 - (void)setMouseDownCanMoveWindow:(BOOL)can_move;
 @end
 
-ShellWindowCocoa::ShellWindowCocoa(ShellWindow* shell_window,
-                                   const ShellWindow::CreateParams& params)
+NativeAppWindowCocoa::NativeAppWindowCocoa(
+    ShellWindow* shell_window,
+    const ShellWindow::CreateParams& params)
     : shell_window_(shell_window),
       has_frame_(params.frame == ShellWindow::CreateParams::FRAME_CHROME),
       attention_request_id_(0),
       use_system_drag_(true) {
   // Flip coordinates based on the primary screen.
   NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
   NSRect cocoa_bounds = NSMakeRect(params.bounds.x(),
       NSHeight(main_screen_rect) - params.bounds.y() - params.bounds.height(),
       params.bounds.width(), params.bounds.height());
 
@@ skipping 35 matching lines @@
     CGFloat max_width = max_size_.width() ? max_size_.width() : CGFLOAT_MAX;
     CGFloat max_height = max_size_.height() ? max_size_.height() : CGFLOAT_MAX;
     [window setContentMaxSize:NSMakeSize(max_width, max_height)];
   }
 
   if (base::mac::IsOSSnowLeopard() &&
       [window respondsToSelector:@selector(setBottomCornerRounded:)])
     [window setBottomCornerRounded:NO];
 
   window_controller_.reset(
-      [[ShellWindowController alloc] initWithWindow:window.release()]);
+      [[NativeAppWindowController alloc] initWithWindow:window.release()]);
 
   NSView* view = web_contents()->GetView()->GetNativeView();
   [view setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
 
   // By default, the whole frameless window is not draggable.
   if (!has_frame_) {
     gfx::Rect window_bounds(
         0, 0, NSWidth(cocoa_bounds), NSHeight(cocoa_bounds));
     system_drag_exclude_areas_.push_back(window_bounds);
   }
 
   InstallView();
 
   [[window_controller_ window] setDelegate:window_controller_];
-  [window_controller_ setShellWindow:this];
+  [window_controller_ setAppWindow:this];
 
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryCocoa(
       shell_window_->profile(),
       window,
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
       shell_window));
 }
 
-void ShellWindowCocoa::InstallView() {
+void NativeAppWindowCocoa::InstallView() {
   NSView* view = web_contents()->GetView()->GetNativeView();
   if (has_frame_) {
     [view setFrame:[[window() contentView] bounds]];
     [[window() contentView] addSubview:view];
     if (!max_size_.IsEmpty() && min_size_ == max_size_) {
       [[window() standardWindowButton:NSWindowZoomButton] setEnabled:NO];
       [window() setShowsResizeIndicator:NO];
     }
   } else {
     // TODO(jeremya): find a cleaner way to send this information to the
@@ skipping 12 matching lines @@
 
     // Some third-party OS X utilities check the zoom button's enabled state to
     // determine whether to show custom UI on hover, so we disable it here to
     // prevent them from doing so in a frameless app window.
     [[window() standardWindowButton:NSWindowZoomButton] setEnabled:NO];
 
     InstallDraggableRegionViews();
   }
 }
 
-void ShellWindowCocoa::UninstallView() {
+void NativeAppWindowCocoa::UninstallView() {
   NSView* view = web_contents()->GetView()->GetNativeView();
   [view removeFromSuperview];
 }
 
-bool ShellWindowCocoa::IsActive() const {
+bool NativeAppWindowCocoa::IsActive() const {
   return [window() isKeyWindow];
 }
 
-bool ShellWindowCocoa::IsMaximized() const {
+bool NativeAppWindowCocoa::IsMaximized() const {
   return [window() isZoomed];
 }
 
-bool ShellWindowCocoa::IsMinimized() const {
+bool NativeAppWindowCocoa::IsMinimized() const {
   return [window() isMiniaturized];
 }
 
-bool ShellWindowCocoa::IsFullscreen() const {
+bool NativeAppWindowCocoa::IsFullscreen() const {
   return is_fullscreen_;
 }
 
-void ShellWindowCocoa::SetFullscreen(bool fullscreen) {
+void NativeAppWindowCocoa::SetFullscreen(bool fullscreen) {
   if (fullscreen == is_fullscreen_)
     return;
   is_fullscreen_ = fullscreen;
 
   if (base::mac::IsOSLionOrLater()) {
     [window() toggleFullScreen:nil];
     return;
   }
 
   DCHECK(base::mac::IsOSSnowLeopard());
@@ skipping 33 matching lines @@
   InstallView();
 
   // Fade back in.
   if (did_fade_out) {
     CGDisplayFade(token, kFadeDurationSeconds / 2, kCGDisplayBlendSolidColor,
         kCGDisplayBlendNormal, 0.0, 0.0, 0.0, /*synchronous=*/false);
     CGReleaseDisplayFadeReservation(token);
   }
 }
 
-bool ShellWindowCocoa::IsFullscreenOrPending() const {
+bool NativeAppWindowCocoa::IsFullscreenOrPending() const {
   return is_fullscreen_;
 }
 
-gfx::NativeWindow ShellWindowCocoa::GetNativeWindow() {
+gfx::NativeWindow NativeAppWindowCocoa::GetNativeWindow() {
   return window();
 }
 
-gfx::Rect ShellWindowCocoa::GetRestoredBounds() const {
+gfx::Rect NativeAppWindowCocoa::GetRestoredBounds() const {
   // Flip coordinates based on the primary screen.
   NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
   NSRect frame = [window() frame];
   gfx::Rect bounds(frame.origin.x, 0, NSWidth(frame), NSHeight(frame));
   bounds.set_y(NSHeight([screen frame]) - NSMaxY(frame));
   return bounds;
 }
 
-gfx::Rect ShellWindowCocoa::GetBounds() const {
+gfx::Rect NativeAppWindowCocoa::GetBounds() const {
   return GetRestoredBounds();
 }
 
-void ShellWindowCocoa::Show() {
+void NativeAppWindowCocoa::Show() {
   [window_controller_ showWindow:nil];
   [window() makeKeyAndOrderFront:window_controller_];
 }
 
-void ShellWindowCocoa::ShowInactive() {
+void NativeAppWindowCocoa::ShowInactive() {
   [window() orderFront:window_controller_];
 }
 
-void ShellWindowCocoa::Hide() {
+void NativeAppWindowCocoa::Hide() {
   [window() orderOut:window_controller_];
 }
 
-void ShellWindowCocoa::Close() {
+void NativeAppWindowCocoa::Close() {
   [window() performClose:nil];
 }
 
-void ShellWindowCocoa::Activate() {
+void NativeAppWindowCocoa::Activate() {
   [BrowserWindowUtils activateWindowForController:window_controller_];
 }
 
-void ShellWindowCocoa::Deactivate() {
+void NativeAppWindowCocoa::Deactivate() {
   // TODO(jcivelli): http://crbug.com/51364 Implement me.
   NOTIMPLEMENTED();
 }
 
-void ShellWindowCocoa::Maximize() {
+void NativeAppWindowCocoa::Maximize() {
   // Zoom toggles so only call if not already maximized.
   if (!IsMaximized())
     [window() zoom:window_controller_];
 }
 
-void ShellWindowCocoa::Minimize() {
+void NativeAppWindowCocoa::Minimize() {
   [window() miniaturize:window_controller_];
 }
 
-void ShellWindowCocoa::Restore() {
+void NativeAppWindowCocoa::Restore() {
   if (IsMaximized())
     [window() zoom:window_controller_];  // Toggles zoom mode.
   else if (IsMinimized())
     [window() deminiaturize:window_controller_];
 }
 
-void ShellWindowCocoa::SetBounds(const gfx::Rect& bounds) {
+void NativeAppWindowCocoa::SetBounds(const gfx::Rect& bounds) {
   // Enforce minimum/maximum bounds.
   gfx::Rect checked_bounds = bounds;
 
   NSSize min_size = [window() minSize];
   if (bounds.width() < min_size.width)
     checked_bounds.set_width(min_size.width);
   if (bounds.height() < min_size.height)
     checked_bounds.set_height(min_size.height);
   NSSize max_size = [window() maxSize];
   if (checked_bounds.width() > max_size.width)
     checked_bounds.set_width(max_size.width);
   if (checked_bounds.height() > max_size.height)
     checked_bounds.set_height(max_size.height);
 
   NSRect cocoa_bounds = NSMakeRect(checked_bounds.x(), 0,
                                    checked_bounds.width(),
                                    checked_bounds.height());
   // Flip coordinates based on the primary screen.
   NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
   cocoa_bounds.origin.y = NSHeight([screen frame]) - checked_bounds.bottom();
 
   [window() setFrame:cocoa_bounds display:YES];
 }
 
-void ShellWindowCocoa::UpdateWindowIcon() {
+void NativeAppWindowCocoa::UpdateWindowIcon() {
   // TODO(junmin): implement.
 }
 
-void ShellWindowCocoa::UpdateWindowTitle() {
+void NativeAppWindowCocoa::UpdateWindowTitle() {
   string16 title = shell_window_->GetTitle();
   [window() setTitle:base::SysUTF16ToNSString(title)];
 }
 
-void ShellWindowCocoa::UpdateDraggableRegions(
+void NativeAppWindowCocoa::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
   if (has_frame_)
     return;
 
   // To use system drag, the window has to be marked as draggable with
   // non-draggable areas being excluded via overlapping views.
   // 1) If no draggable area is provided, the window is not draggable at all.
   // 2) If only one draggable area is given, as this is the most common
   //    case, use the system drag. The non-draggable areas that are opposite of
@@ skipping 20 matching lines @@
   }
 
   if (use_system_drag_)
     UpdateDraggableRegionsForSystemDrag(regions, draggable_area);
   else
     UpdateDraggableRegionsForCustomDrag(regions);
 
   InstallDraggableRegionViews();
 }
 
-void ShellWindowCocoa::UpdateDraggableRegionsForSystemDrag(
+void NativeAppWindowCocoa::UpdateDraggableRegionsForSystemDrag(
     const std::vector<extensions::DraggableRegion>& regions,
     const extensions::DraggableRegion* draggable_area) {
   NSView* web_view = web_contents()->GetView()->GetNativeView();
   NSInteger web_view_width = NSWidth([web_view bounds]);
   NSInteger web_view_height = NSHeight([web_view bounds]);
 
   system_drag_exclude_areas_.clear();
 
   // The whole window is not draggable if no draggable area is given.
   if (!draggable_area) {
@@ skipping 48 matching lines @@
   // Add the non-draggable area to the right of the given draggable area.
   if (draggable_bounds.right() < web_view_width) {
     non_draggable_bounds.SetRect(draggable_bounds.right() + 1,
                                  draggable_bounds.y(),
                                  web_view_width - draggable_bounds.right(),
                                  draggable_bounds.height());
     system_drag_exclude_areas_.push_back(non_draggable_bounds);
   }
 }
 
-void ShellWindowCocoa::UpdateDraggableRegionsForCustomDrag(
+void NativeAppWindowCocoa::UpdateDraggableRegionsForCustomDrag(
     const std::vector<extensions::DraggableRegion>& regions) {
   // We still need one ControlRegionView to cover the whole window such that
   // mouse events could be captured.
   NSView* web_view = web_contents()->GetView()->GetNativeView();
   gfx::Rect window_bounds(
       0, 0, NSWidth([web_view bounds]), NSHeight([web_view bounds]));
   system_drag_exclude_areas_.clear();
   system_drag_exclude_areas_.push_back(window_bounds);
 
   // Aggregate the draggable areas and non-draggable areas such that hit test
   // could be performed easily.
   draggable_region_.reset(ShellWindow::RawDraggableRegionsToSkRegion(regions));
 }
 
-void ShellWindowCocoa::HandleKeyboardEvent(
+void NativeAppWindowCocoa::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   if (event.skip_in_browser ||
       event.type == content::NativeWebKeyboardEvent::Char) {
     return;
   }
   [window() redispatchKeyEvent:event.os_event];
 }
 
-void ShellWindowCocoa::InstallDraggableRegionViews() {
+void NativeAppWindowCocoa::InstallDraggableRegionViews() {
   DCHECK(!has_frame_);
 
   // All ControlRegionViews should be added as children of the WebContentsView,
   // because WebContentsView will be removed and re-added when entering and
   // leaving fullscreen mode.
   NSView* webView = web_contents()->GetView()->GetNativeView();
   NSInteger webViewHeight = NSHeight([webView bounds]);
 
   // Remove all ControlRegionViews that are added last time.
   // Note that [webView subviews] returns the view's mutable internal array and
   // it should be copied to avoid mutating the original array while enumerating
   // it.
   scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
   for (NSView* subview in subviews.get())
     if ([subview isKindOfClass:[ControlRegionView class]])
       [subview removeFromSuperview];
 
   // Create and add ControlRegionView for each region that needs to be excluded
   // from the dragging.
   for (std::vector<gfx::Rect>::const_iterator iter =
            system_drag_exclude_areas_.begin();
        iter != system_drag_exclude_areas_.end();
        ++iter) {
     scoped_nsobject<NSView> controlRegion(
-        [[ControlRegionView alloc] initWithShellWindow:this]);
+        [[ControlRegionView alloc] initWithAppWindow:this]);
     [controlRegion setFrame:NSMakeRect(iter->x(),
                                        webViewHeight - iter->bottom(),
                                        iter->width(),
                                        iter->height())];
     [webView addSubview:controlRegion];
   }
 }
 
-void ShellWindowCocoa::FlashFrame(bool flash) {
+void NativeAppWindowCocoa::FlashFrame(bool flash) {
   if (flash) {
     attention_request_id_ = [NSApp requestUserAttention:NSInformationalRequest];
   } else {
     [NSApp cancelUserAttentionRequest:attention_request_id_];
     attention_request_id_ = 0;
   }
 }
 
-bool ShellWindowCocoa::IsAlwaysOnTop() const {
+bool NativeAppWindowCocoa::IsAlwaysOnTop() const {
   return false;
 }
 
-void ShellWindowCocoa::WindowWillClose() {
-  [window_controller_ setShellWindow:NULL];
+void NativeAppWindowCocoa::WindowWillClose() {
+  [window_controller_ setAppWindow:NULL];
   shell_window_->OnNativeWindowChanged();
   shell_window_->OnNativeClose();
 }
 
-void ShellWindowCocoa::WindowDidBecomeKey() {
+void NativeAppWindowCocoa::WindowDidBecomeKey() {
   content::RenderWidgetHostView* rwhv =
       web_contents()->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetActive(true);
 }
 
-void ShellWindowCocoa::WindowDidResignKey() {
+void NativeAppWindowCocoa::WindowDidResignKey() {
   // If our app is still active and we're still the key window, ignore this
   // message, since it just means that a menu extra (on the "system status bar")
   // was activated; we'll get another |-windowDidResignKey| if we ever really
   // lose key window status.
   if ([NSApp isActive] && ([NSApp keyWindow] == window()))
     return;
 
   content::RenderWidgetHostView* rwhv =
       web_contents()->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetActive(false);
 }
 
-void ShellWindowCocoa::WindowDidResize() {
+void NativeAppWindowCocoa::WindowDidResize() {
   shell_window_->OnNativeWindowChanged();
 }
 
-void ShellWindowCocoa::WindowDidMove() {
+void NativeAppWindowCocoa::WindowDidMove() {
   shell_window_->OnNativeWindowChanged();
 }
 
-bool ShellWindowCocoa::HandledByExtensionCommand(NSEvent* event) {
+bool NativeAppWindowCocoa::HandledByExtensionCommand(NSEvent* event) {
   return extension_keybinding_registry_->ProcessKeyEvent(
       content::NativeWebKeyboardEvent(event));
 }
 
-void ShellWindowCocoa::HandleMouseEvent(NSEvent* event) {
+void NativeAppWindowCocoa::HandleMouseEvent(NSEvent* event) {
   if ([event type] == NSLeftMouseDown) {
     last_mouse_location_ =
         [window() convertBaseToScreen:[event locationInWindow]];
   } else if ([event type] == NSLeftMouseDragged) {
     NSPoint current_mouse_location =
         [window() convertBaseToScreen:[event locationInWindow]];
     NSPoint frame_origin = [window() frame].origin;
     frame_origin.x += current_mouse_location.x - last_mouse_location_.x;
     frame_origin.y += current_mouse_location.y - last_mouse_location_.y;
     [window() setFrameOrigin:frame_origin];
     last_mouse_location_ = current_mouse_location;
   }
 }
 
-bool ShellWindowCocoa::IsWithinDraggableRegion(NSPoint point) const {
+bool NativeAppWindowCocoa::IsWithinDraggableRegion(NSPoint point) const {
   if (!draggable_region_)
     return false;
   NSView* webView = web_contents()->GetView()->GetNativeView();
   NSInteger webViewHeight = NSHeight([webView bounds]);
   // |draggable_region_| is stored in local platform-indepdent coordiate system
   // while |point| is in local Cocoa coordinate system. Do the conversion
   // to match these two.
   return draggable_region_->contains(point.x, webViewHeight - point.y);
 }
 
-ShellWindowCocoa::~ShellWindowCocoa() {
+NativeAppWindowCocoa::~NativeAppWindowCocoa() {
 }
 
-ShellNSWindow* ShellWindowCocoa::window() const {
+ShellNSWindow* NativeAppWindowCocoa::window() const {
   NSWindow* window = [window_controller_ window];
   CHECK(!window || [window isKindOfClass:[ShellNSWindow class]]);
   return static_cast<ShellNSWindow*>(window);
 }
 
 // static
-NativeShellWindow* NativeShellWindow::Create(
-    ShellWindow* shell_window, const ShellWindow::CreateParams& params) {
-  return new ShellWindowCocoa(shell_window, params);
+NativeAppWindow* NativeAppWindow::Create(
+    ShellWindow* shell_window,
+    const ShellWindow::CreateParams& params) {
+  return new NativeAppWindowCocoa(shell_window, params);
 }