Extract NativeAppWindow from src/extensions

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

 // Copyright 2014 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/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"
 #include "chrome/browser/ui/views/extensions/extension_keybinding_registry_views.h"
 #include "chrome/browser/ui/views/frame/taskbar_decorator.h"
 #include "chrome/browser/ui/zoom/zoom_controller.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_switches.h"
+#include "extensions/browser/app_window/app_window.h"
 #include "extensions/common/extension.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/easy_resize_window_targeter.h"
 #include "ui/wm/core/shadow_types.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/ui/ash/multi_user/multi_user_context_menu.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/window_observer.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "ash/shell_window_ids.h"
 #endif
 
-using extensions::AppWindow;
-
 namespace {
 
 const int kMinPanelWidth = 100;
 const int kMinPanelHeight = 100;
 const int kDefaultPanelWidth = 200;
 const int kDefaultPanelHeight = 300;
 
 struct AcceleratorMapping {
   ui::KeyboardCode keycode;
   int modifiers;
@@ skipping 50 matching lines @@
   }
   return accelerators;
 }
 
 #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(AppWindow* app_window,
-                               extensions::NativeAppWindow* native_app_window)
+  NativeAppWindowStateDelegate(
+      extensions::AppWindow* app_window,
+      native_app_window::NativeAppWindow* native_app_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 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);
@@ skipping 36 matching lines @@
   }
 
   // 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.
-  AppWindow* app_window_;
+  extensions::AppWindow* app_window_;
   ash::wm::WindowState* window_state_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeAppWindowStateDelegate);
 };
 #endif  // USE_ASH
 
 }  // namespace
 
-ChromeNativeAppWindowViews::ChromeNativeAppWindowViews()
+ChromeNativeAppWindowViews::ChromeNativeAppWindowViews(
+    extensions::AppWindow* extensions_app_window)
     : is_fullscreen_(false),
       has_frame_color_(false),
       active_frame_color_(SK_ColorBLACK),
-      inactive_frame_color_(SK_ColorBLACK) {
+      inactive_frame_color_(SK_ColorBLACK),
+      extensions_app_window_(extensions_app_window) {
 }
 
 ChromeNativeAppWindowViews::~ChromeNativeAppWindowViews() {}
 
 void ChromeNativeAppWindowViews::OnBeforeWidgetInit(
     views::Widget::InitParams* init_params,
     views::Widget* widget) {}
 
 void ChromeNativeAppWindowViews::InitializeDefaultWindow(
-    const AppWindow::CreateParams& create_params) {
+    const native_app_window::AppWindowCreateParams& create_params) {
   std::string app_name = web_app::GenerateApplicationNameFromExtensionId(
-      app_window()->extension_id());
+      extensions_app_window_->extension_id());
 
   views::Widget::InitParams init_params(views::Widget::InitParams::TYPE_WINDOW);
   init_params.delegate = this;
   init_params.remove_standard_frame = IsFrameless() || has_frame_color_;
   init_params.use_system_default_icon = true;
   if (create_params.alpha_enabled)
     init_params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   init_params.keep_on_top = create_params.always_on_top;
   init_params.visible_on_all_workspaces =
       create_params.visible_on_all_workspaces;
@@ skipping 18 matching lines @@
 #endif
   widget()->Init(init_params);
 
   // The frame insets are required to resolve the bounds specifications
   // correctly. So we set the window bounds and constraints now.
   gfx::Insets frame_insets = GetFrameInsets();
   gfx::Rect window_bounds = create_params.GetInitialWindowBounds(frame_insets);
   SetContentSizeConstraints(create_params.GetContentMinimumSize(frame_insets),
                             create_params.GetContentMaximumSize(frame_insets));
   if (!window_bounds.IsEmpty()) {
-    typedef AppWindow::BoundsSpecification BoundsSpecification;
+    typedef native_app_window::BoundsSpecification BoundsSpecification;
     bool position_specified =
         window_bounds.x() != BoundsSpecification::kUnspecifiedPosition &&
         window_bounds.y() != BoundsSpecification::kUnspecifiedPosition;
     if (!position_specified)
       widget()->CenterWindow(window_bounds.size());
     else
       widget()->SetBounds(window_bounds);
   }
 
   if (IsFrameless() &&
@@ skipping 37 matching lines @@
        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 ChromeNativeAppWindowViews::InitializePanelWindow(
-    const AppWindow::CreateParams& create_params) {
+    const native_app_window::AppWindowCreateParams& create_params) {
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_PANEL);
   params.delegate = this;
 
   gfx::Rect initial_window_bounds =
       create_params.GetInitialWindowBounds(gfx::Insets());
   preferred_size_ = gfx::Size(initial_window_bounds.width(),
                               initial_window_bounds.height());
   if (preferred_size_.width() == 0)
     preferred_size_.set_width(kDefaultPanelWidth);
   else if (preferred_size_.width() < kMinPanelWidth)
@@ skipping 117 matching lines @@
     case ui::SHOW_STATE_MINIMIZED:
     case ui::SHOW_STATE_INACTIVE:
     case ui::SHOW_STATE_END:
       return ui::SHOW_STATE_NORMAL;
   }
 #endif  // !defined(USE_ASH)
   return ui::SHOW_STATE_NORMAL;
 }
 
 bool ChromeNativeAppWindowViews::IsAlwaysOnTop() const {
-  if (app_window()->window_type_is_panel()) {
+  if (app_window()->WindowTypeIsPanel()) {
 #if defined(USE_ASH)
     return ash::wm::GetWindowState(widget()->GetNativeWindow())
         ->panel_attached();
 #else
     return true;
 #endif
   } else {
     return widget()->IsAlwaysOnTop();
   }
 }
@@ skipping 28 matching lines @@
         views::MenuRunner::MENU_DELETED) {
       return;
     }
   }
 #endif
 }
 
 // views::WidgetDelegate implementation.
 
 gfx::ImageSkia ChromeNativeAppWindowViews::GetWindowAppIcon() {
-  gfx::Image app_icon = app_window()->app_icon();
+  gfx::Image app_icon = extensions_app_window_->app_icon();
   if (app_icon.IsEmpty())
     return GetWindowIcon();
   else
     return *app_icon.ToImageSkia();
 }
 
 gfx::ImageSkia ChromeNativeAppWindowViews::GetWindowIcon() {
-  content::WebContents* web_contents = app_window()->web_contents();
+  content::WebContents* web_contents = app_window()->GetWebContents();
   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* 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());
+    ash::wm::GetWindowState(GetNativeWindow())
+        ->SetDelegate(scoped_ptr<ash::wm::WindowStateDelegate>(
+                          new NativeAppWindowStateDelegate(
+                              extensions_app_window_, this)).Pass());
 
-    if (app_window()->window_type_is_panel()) {
+    if (app_window()->WindowTypeIsPanel()) {
       ash::PanelFrameView::FrameType frame_type = IsFrameless() ?
           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 (IsFrameless())
       return CreateNonStandardAppFrame();
@@ skipping 56 matching lines @@
     default:
       NOTREACHED() << "Unknown accelerator sent to app window.";
   }
   return NativeAppWindowViews::AcceleratorPressed(accelerator);
 }
 
 // NativeAppWindow implementation.
 
 void ChromeNativeAppWindowViews::SetFullscreen(int fullscreen_types) {
   // Fullscreen not supported by panels.
-  if (app_window()->window_type_is_panel())
+  if (app_window()->WindowTypeIsPanel())
     return;
-  is_fullscreen_ = (fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
+  is_fullscreen_ =
+      (fullscreen_types != native_app_window::FULLSCREEN_TYPE_NONE);
   widget()->SetFullscreen(is_fullscreen_);
 
   // TODO(oshima): Remove USE_ATHENA once athena has its own NativeAppWindow.
 #if defined(USE_ASH) && !defined(USE_ATHENA)
   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);
+        (fullscreen_types & native_app_window::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(widget()->GetNativeWindow());
-    window_state->set_hide_shelf_when_fullscreen(fullscreen_types !=
-                                                 AppWindow::FULLSCREEN_TYPE_OS);
+    window_state->set_hide_shelf_when_fullscreen(
+        fullscreen_types != native_app_window::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 ChromeNativeAppWindowViews::IsFullscreenOrPending() const {
   return is_fullscreen_;
 }
 
 void ChromeNativeAppWindowViews::UpdateBadgeIcon() {
   const gfx::Image* icon = NULL;
-  if (!app_window()->badge_icon().IsEmpty()) {
-    icon = &app_window()->badge_icon();
+  if (!extensions_app_window_->badge_icon().IsEmpty()) {
+    icon = &extensions_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);
@@ skipping 26 matching lines @@
   return active_frame_color_;
 }
 
 SkColor ChromeNativeAppWindowViews::InactiveFrameColor() const {
   return inactive_frame_color_;
 }
 
 // NativeAppWindowViews implementation.
 
 void ChromeNativeAppWindowViews::InitializeWindow(
-    AppWindow* app_window,
-    const AppWindow::CreateParams& create_params) {
+    native_app_window::NativeAppWindowDelegate* app_window,
+    const native_app_window::AppWindowCreateParams& create_params) {
   DCHECK(widget());
   has_frame_color_ = create_params.has_frame_color;
   active_frame_color_ = create_params.active_frame_color;
   inactive_frame_color_ = create_params.inactive_frame_color;
-  if (create_params.window_type == AppWindow::WINDOW_TYPE_PANEL ||
-      create_params.window_type == AppWindow::WINDOW_TYPE_V1_PANEL) {
+  if (create_params.window_type == native_app_window::WINDOW_TYPE_PANEL ||
+      create_params.window_type == native_app_window::WINDOW_TYPE_V1_PANEL) {
     InitializePanelWindow(create_params);
   } else {
     InitializeDefaultWindow(create_params);
   }
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryViews(
-      Profile::FromBrowserContext(app_window->browser_context()),
+      Profile::FromBrowserContext(app_window->GetBrowserContext()),
       widget()->GetFocusManager(),
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
       NULL));
 }