Rename apps::ShellWindow to apps::AppWindow

chrome/browser/ui/views/apps/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 "apps/shell_window.h"
-#include "apps/ui/views/shell_window_frame_view.h"
+#include "apps/app_window.h"
+#include "apps/ui/views/app_window_frame_view.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.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/extensions/extension_host.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 45 matching lines @@
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #endif
 
 #if defined(USE_AURA)
 #include "ui/aura/window.h"
 #endif
 
-using apps::ShellWindow;
+using apps::AppWindow;
 
 namespace {
 
 const int kMinPanelWidth = 100;
 const int kMinPanelHeight = 100;
 const int kDefaultPanelWidth = 200;
 const int kDefaultPanelHeight = 300;
 const int kResizeInsideBoundsSize = 5;
 const int kResizeAreaCornerSize = 16;
 
@@ skipping 86 matching lines @@
   web_app::internals::CheckAndSaveIcon(icon_file, shortcut_info.favicon);
 }
 #endif
 
 #if defined(USE_ASH)
 // This class handles a user's fullscreen request (Shift+F4/F4).
 class NativeAppWindowStateDelegate : public ash::wm::WindowStateDelegate,
                                      public ash::wm::WindowStateObserver,
                                      public aura::WindowObserver {
  public:
-  NativeAppWindowStateDelegate(ShellWindow* shell_window,
+  NativeAppWindowStateDelegate(AppWindow* app_window,
                                apps::NativeAppWindow* native_app_window)
-      : shell_window_(shell_window),
+      : app_window_(app_window),
         window_state_(
             ash::wm::GetWindowState(native_app_window->GetNativeWindow())) {
     // Add a window state observer to exit fullscreen properly in case
-    // fullscreen is exited without going through ShellWindow::Restore(). This
+    // fullscreen is exited without going through AppWindow::Restore(). This
     // is the case when exiting immersive fullscreen via the "Restore" window
     // control.
     // TODO(pkotwicz): This is a hack. Remove ASAP. http://crbug.com/319048
     window_state_->AddObserver(this);
     window_state_->window()->AddObserver(this);
   }
   virtual ~NativeAppWindowStateDelegate(){
     if (window_state_) {
       window_state_->RemoveObserver(this);
       window_state_->window()->RemoveObserver(this);
     }
   }
 
  private:
   // Overridden from ash::wm::WindowStateDelegate.
   virtual bool ToggleFullscreen(ash::wm::WindowState* window_state) OVERRIDE {
     // Windows which cannot be maximized should not be fullscreened.
     DCHECK(window_state->IsFullscreen() || window_state->CanMaximize());
     if (window_state->IsFullscreen())
-      shell_window_->Restore();
+      app_window_->Restore();
     else if (window_state->CanMaximize())
-      shell_window_->OSFullscreen();
+      app_window_->OSFullscreen();
     return true;
   }
 
   // Overridden from ash::wm::WindowStateObserver:
   virtual void OnWindowShowTypeChanged(
       ash::wm::WindowState* window_state,
       ash::wm::WindowShowType old_type) OVERRIDE {
-    if (!window_state->IsFullscreen() &&
-        !window_state->IsMinimized() &&
-        shell_window_->GetBaseWindow()->IsFullscreenOrPending()) {
-      shell_window_->Restore();
+    if (!window_state->IsFullscreen() && !window_state->IsMinimized() &&
+        app_window_->GetBaseWindow()->IsFullscreenOrPending()) {
+      app_window_->Restore();
       // Usually OnNativeWindowChanged() is called when the window bounds are
       // changed as a result of a show type change. Because the change in show
       // type has already occurred, we need to call OnNativeWindowChanged()
       // explicitly.
-      shell_window_->OnNativeWindowChanged();
+      app_window_->OnNativeWindowChanged();
     }
   }
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
     window_state_->RemoveObserver(this);
     window_state_->window()->RemoveObserver(this);
     window_state_ = NULL;
   }
 
   // Not owned.
-  ShellWindow* shell_window_;
+  AppWindow* app_window_;
   ash::wm::WindowState* window_state_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeAppWindowStateDelegate);
 };
 #endif  // USE_ASH
 
 }  // namespace
 
 NativeAppWindowViews::NativeAppWindowViews()
     : web_view_(NULL),
       window_(NULL),
       is_fullscreen_(false),
       weak_ptr_factory_(this) {
 }
 
-void NativeAppWindowViews::Init(
-    apps::ShellWindow* shell_window,
-    const ShellWindow::CreateParams& create_params) {
-  shell_window_ = shell_window;
-  frameless_ = create_params.frame == ShellWindow::FRAME_NONE;
+void NativeAppWindowViews::Init(apps::AppWindow* app_window,
+                                const AppWindow::CreateParams& create_params) {
+  app_window_ = app_window;
+  frameless_ = create_params.frame == AppWindow::FRAME_NONE;
   transparent_background_ = create_params.transparent_background;
   resizable_ = create_params.resizable;
   Observe(web_contents());
 
   window_ = new views::Widget;
-  if (create_params.window_type == ShellWindow::WINDOW_TYPE_PANEL ||
-      create_params.window_type == ShellWindow::WINDOW_TYPE_V1_PANEL) {
+  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(browser_context()),
       window_->GetFocusManager(),
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
-      shell_window_));
+      app_window_));
 
   OnViewWasResized();
   window_->AddObserver(this);
 }
 
 NativeAppWindowViews::~NativeAppWindowViews() {
   web_view_->SetWebContents(NULL);
 }
 
 void NativeAppWindowViews::OnBeforeWidgetInit(
     views::Widget::InitParams* init_params,
     views::Widget* widget) {}
 
 void NativeAppWindowViews::InitializeDefaultWindow(
-    const ShellWindow::CreateParams& create_params) {
+    const AppWindow::CreateParams& create_params) {
   std::string app_name =
       web_app::GenerateApplicationNameFromExtensionId(extension()->id());
 
   views::Widget::InitParams init_params(views::Widget::InitParams::TYPE_WINDOW);
   init_params.delegate = this;
   init_params.remove_standard_frame = ShouldUseChromeStyleFrame();
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // On Linux, remove the standard frame. Instead, we will use CustomFrameView
   // to draw a native-like frame.
   // TODO(mgiuca): Remove this during fix for http://crbug.com/322256.
@@ skipping 97 matching lines @@
       base::Bind(&CreateIconAndSetRelaunchDetails,
                  web_app_path, icon_file, shortcut_info, hwnd));
 }
 
 HWND NativeAppWindowViews::GetNativeAppWindowHWND() const {
   return views::HWNDForWidget(window_->GetTopLevelWidget());
 }
 #endif
 
 void NativeAppWindowViews::InitializePanelWindow(
-    const ShellWindow::CreateParams& create_params) {
+    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 44 matching lines @@
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // Linux always uses native style frames.
   return false;
 #endif
 
   return !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAppsUseNativeFrame);
 }
 
-apps::ShellWindowFrameView* NativeAppWindowViews::CreateShellWindowFrameView() {
+apps::AppWindowFrameView* NativeAppWindowViews::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::ShellWindowFrameView* frame_view = new apps::ShellWindowFrameView(this);
+  apps::AppWindowFrameView* frame_view = new apps::AppWindowFrameView(this);
   frame_view->Init(window_,
                    resize_inside_bounds_size,
                    resize_outside_bounds_size,
                    resize_outside_scale_for_touch,
                    resize_area_corner_size);
   return frame_view;
 }
 
 // ui::BaseWindow implementation.
 
@@ skipping 109 matching lines @@
 
 void NativeAppWindowViews::SetBounds(const gfx::Rect& bounds) {
   window_->SetBounds(bounds);
 }
 
 void NativeAppWindowViews::FlashFrame(bool flash) {
   window_->FlashFrame(flash);
 }
 
 bool NativeAppWindowViews::IsAlwaysOnTop() const {
-  if (shell_window_->window_type_is_panel()) {
+  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();
   }
 }
 
 void NativeAppWindowViews::SetAlwaysOnTop(bool always_on_top) {
   window_->SetAlwaysOnTop(always_on_top);
 }
 
 void NativeAppWindowViews::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(
-      shell_window_->GetNativeWindow());
+  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
 }
 
 gfx::NativeView NativeAppWindowViews::GetHostView() const {
   return window_->GetNativeView();
 }
 
 gfx::Point NativeAppWindowViews::GetDialogPosition(const gfx::Size& size) {
-  gfx::Size shell_window_size = window_->GetWindowBoundsInScreen().size();
-  return gfx::Point(shell_window_size.width() / 2 - size.width() / 2,
-                    shell_window_size.height() / 2 - size.height() / 2);
+  gfx::Size app_window_size = window_->GetWindowBoundsInScreen().size();
+  return gfx::Point(app_window_size.width() / 2 - size.width() / 2,
+                    app_window_size.height() / 2 - size.height() / 2);
 }
 
 gfx::Size NativeAppWindowViews::GetMaximumDialogSize() {
   return window_->GetWindowBoundsInScreen().size();
 }
 
 void NativeAppWindowViews::AddObserver(
     web_modal::ModalDialogHostObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 void NativeAppWindowViews::RemoveObserver(
     web_modal::ModalDialogHostObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 // Private method. TODO(stevenjb): Move this below InitializePanelWindow()
 // to match declaration order.
 void NativeAppWindowViews::OnViewWasResized() {
   FOR_EACH_OBSERVER(web_modal::ModalDialogHostObserver,
                     observer_list_,
                     OnPositionRequiresUpdate());
 }
 
 // WidgetDelegate implementation.
 
 void NativeAppWindowViews::OnWidgetMove() {
-  shell_window_->OnNativeWindowChanged();
+  app_window_->OnNativeWindowChanged();
 }
 
 views::View* NativeAppWindowViews::GetInitiallyFocusedView() {
   return web_view_;
 }
 
 bool NativeAppWindowViews::CanResize() const {
-  return resizable_ && !shell_window_->size_constraints().HasFixedSize();
+  return resizable_ && !app_window_->size_constraints().HasFixedSize();
 }
 
 bool NativeAppWindowViews::CanMaximize() const {
-  return resizable_ && !shell_window_->size_constraints().HasMaximumSize() &&
-      !shell_window_->window_type_is_panel();
+  return resizable_ && !app_window_->size_constraints().HasMaximumSize() &&
+         !app_window_->window_type_is_panel();
 }
 
 base::string16 NativeAppWindowViews::GetWindowTitle() const {
-  return shell_window_->GetTitle();
+  return app_window_->GetTitle();
 }
 
 bool NativeAppWindowViews::ShouldShowWindowTitle() const {
-  return shell_window_->window_type() == ShellWindow::WINDOW_TYPE_V1_PANEL;
+  return app_window_->window_type() == AppWindow::WINDOW_TYPE_V1_PANEL;
 }
 
 gfx::ImageSkia NativeAppWindowViews::GetWindowAppIcon() {
-  gfx::Image app_icon = shell_window_->app_icon();
+  gfx::Image app_icon = app_window_->app_icon();
   if (app_icon.IsEmpty())
     return GetWindowIcon();
   else
     return *app_icon.ToImageSkia();
 }
 
 gfx::ImageSkia NativeAppWindowViews::GetWindowIcon() {
-  content::WebContents* web_contents = shell_window_->web_contents();
+  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();
 }
 
 bool NativeAppWindowViews::ShouldShowWindowIcon() const {
-  return shell_window_->window_type() == ShellWindow::WINDOW_TYPE_V1_PANEL;
+  return app_window_->window_type() == AppWindow::WINDOW_TYPE_V1_PANEL;
 }
 
 void NativeAppWindowViews::SaveWindowPlacement(const gfx::Rect& bounds,
                                                ui::WindowShowState show_state) {
   views::WidgetDelegate::SaveWindowPlacement(bounds, show_state);
-  shell_window_->OnNativeWindowChanged();
+  app_window_->OnNativeWindowChanged();
 }
 
 void NativeAppWindowViews::DeleteDelegate() {
   window_->RemoveObserver(this);
-  shell_window_->OnNativeClose();
+  app_window_->OnNativeClose();
 }
 
 views::Widget* NativeAppWindowViews::GetWidget() {
   return window_;
 }
 
 const views::Widget* NativeAppWindowViews::GetWidget() const {
   return window_;
 }
 
 views::View* NativeAppWindowViews::GetContentsView() {
   return this;
 }
 
 views::NonClientFrameView* NativeAppWindowViews::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(shell_window_, this)).Pass());
+            new NativeAppWindowStateDelegate(app_window_, this)).Pass());
 
-    if (shell_window_->window_type_is_panel()) {
+    if (app_window_->window_type_is_panel()) {
       ash::PanelFrameView::FrameType frame_type = frameless_ ?
           ash::PanelFrameView::FRAME_NONE : ash::PanelFrameView::FRAME_ASH;
       views::NonClientFrameView* frame_view =
           new ash::PanelFrameView(widget, frame_type);
       frame_view->set_context_menu_controller(this);
       return frame_view;
     }
 
     if (!frameless_) {
       ash::CustomFrameViewAsh* custom_frame_view =
           new ash::CustomFrameViewAsh(widget);
 #if defined(OS_CHROMEOS)
       // Non-frameless app windows can be put into immersive fullscreen.
       // TODO(pkotwicz): Investigate if immersive fullscreen can be enabled for
       // Windows Ash.
       if (ash::switches::UseImmersiveFullscreenForAllWindows()) {
         immersive_fullscreen_controller_.reset(
             new ash::ImmersiveFullscreenController());
         custom_frame_view->InitImmersiveFullscreenControllerForView(
             immersive_fullscreen_controller_.get());
       }
 #endif
       custom_frame_view->GetHeaderView()->set_context_menu_controller(this);
       return custom_frame_view;
     }
   }
 #endif
   if (ShouldUseChromeStyleFrame())
-    return CreateShellWindowFrameView();
+    return CreateAppWindowFrameView();
   return views::WidgetDelegateView::CreateNonClientFrameView(widget);
 }
 
 bool NativeAppWindowViews::WidgetHasHitTestMask() const {
   return shape_ != NULL;
 }
 
 void NativeAppWindowViews::GetWidgetHitTestMask(gfx::Path* mask) const {
   shape_->getBoundaryPath(mask);
 }
 
 bool NativeAppWindowViews::ShouldDescendIntoChildForEventHandling(
     gfx::NativeView child,
     const gfx::Point& location) {
 #if defined(USE_AURA)
   if (child->Contains(web_view_->web_contents()->GetView()->GetNativeView())) {
-    // Shell window should claim mouse events that fall within the draggable
+    // App window should claim mouse events that fall within the draggable
     // region.
     return !draggable_region_.get() ||
            !draggable_region_->contains(location.x(), location.y());
   }
 #endif
 
   return true;
 }
 
 // WidgetObserver implementation.
 
 void NativeAppWindowViews::OnWidgetVisibilityChanged(views::Widget* widget,
                                                      bool visible) {
-  shell_window_->OnNativeWindowChanged();
+  app_window_->OnNativeWindowChanged();
 }
 
 void NativeAppWindowViews::OnWidgetActivationChanged(views::Widget* widget,
                                                      bool active) {
-  shell_window_->OnNativeWindowChanged();
+  app_window_->OnNativeWindowChanged();
   if (active)
-    shell_window_->OnNativeWindowActivated();
+    app_window_->OnNativeWindowActivated();
 }
 
 // WebContentsObserver implementation.
 
 void NativeAppWindowViews::RenderViewCreated(
     content::RenderViewHost* render_view_host) {
   if (transparent_background_) {
     // Use a background with transparency to trigger transparency in Webkit.
     SkBitmap background;
     background.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
@@ skipping 29 matching lines @@
   }
 }
 
 gfx::Size NativeAppWindowViews::GetPreferredSize() {
   if (!preferred_size_.IsEmpty())
     return preferred_size_;
   return views::View::GetPreferredSize();
 }
 
 gfx::Size NativeAppWindowViews::GetMinimumSize() {
-  return shell_window_->size_constraints().GetMinimumSize();
+  return app_window_->size_constraints().GetMinimumSize();
 }
 
 gfx::Size NativeAppWindowViews::GetMaximumSize() {
-  return shell_window_->size_constraints().GetMaximumSize();
+  return app_window_->size_constraints().GetMaximumSize();
 }
 
 void NativeAppWindowViews::OnFocus() {
   web_view_->RequestFocus();
 }
 
 bool NativeAppWindowViews::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
   const std::map<ui::Accelerator, int>& accelerator_table =
       GetAcceleratorTable();
@@ skipping 20 matching lines @@
     default:
       NOTREACHED() << "Unknown accelerator sent to app window.";
   }
   return false;
 }
 
 // NativeAppWindow implementation.
 
 void NativeAppWindowViews::SetFullscreen(int fullscreen_types) {
   // Fullscreen not supported by panels.
-  if (shell_window_->window_type_is_panel())
+  if (app_window_->window_type_is_panel())
     return;
-  is_fullscreen_ = (fullscreen_types != ShellWindow::FULLSCREEN_TYPE_NONE);
+  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 & ShellWindow::FULLSCREEN_TYPE_OS) != 0);
+        (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 != ShellWindow::FULLSCREEN_TYPE_OS);
+    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 {
   return is_fullscreen_;
 }
 
 bool NativeAppWindowViews::IsDetached() const {
-  if (!shell_window_->window_type_is_panel())
+  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::UpdateWindowIcon() {
   window_->UpdateWindowIcon();
 }
 
 void NativeAppWindowViews::UpdateWindowTitle() {
   window_->UpdateWindowTitle();
 }
 
 void NativeAppWindowViews::UpdateBadgeIcon() {
   const gfx::Image* icon = NULL;
-  if (!shell_window_->badge_icon().IsEmpty()) {
-    icon = &shell_window_->badge_icon();
+  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::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));
+  draggable_region_.reset(AppWindow::RawDraggableRegionsToSkRegion(regions));
   OnViewWasResized();
 }
 
 SkRegion* NativeAppWindowViews::GetDraggableRegion() {
   return draggable_region_.get();
 }
 
 void NativeAppWindowViews::UpdateShape(scoped_ptr<SkRegion> region) {
   bool had_shape = shape_;
   shape_ = region.Pass();
@@ skipping 34 matching lines @@
   gfx::Rect client_bounds = gfx::Rect(1000, 1000);
   gfx::Rect window_bounds =
       window_->non_client_view()->GetWindowBoundsForClientBounds(
           client_bounds);
   return window_bounds.InsetsFrom(client_bounds);
 }
 
 void NativeAppWindowViews::HideWithApp() {}
 void NativeAppWindowViews::ShowWithApp() {}
 void NativeAppWindowViews::UpdateWindowMinMaxSize() {}