Move AppWindow to extensions

apps/app_window.cc

Index: apps/app_window.cc
diff --git a/apps/app_window.cc b/apps/app_window.cc
deleted file mode 100644
index 7fd02cd87da22a5364fef9f72d601ad882339ce0..0000000000000000000000000000000000000000
--- a/apps/app_window.cc
+++ /dev/null
@@ -1,1099 +0,0 @@
-// 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 "apps/app_window.h"
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "apps/app_window_registry.h"
-#include "apps/ui/apps_client.h"
-#include "base/command_line.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
-#include "components/web_modal/web_contents_modal_dialog_manager.h"
-#include "content/public/browser/browser_context.h"
-#include "content/public/browser/invalidate_type.h"
-#include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/browser/notification_types.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/resource_dispatcher_host.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/common/content_switches.h"
-#include "content/public/common/media_stream_request.h"
-#include "extensions/browser/app_window/app_delegate.h"
-#include "extensions/browser/app_window/app_web_contents_helper.h"
-#include "extensions/browser/app_window/app_window_geometry_cache.h"
-#include "extensions/browser/app_window/native_app_window.h"
-#include "extensions/browser/app_window/size_constraints.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/browser/extensions_browser_client.h"
-#include "extensions/browser/notification_types.h"
-#include "extensions/browser/process_manager.h"
-#include "extensions/browser/suggest_permission_util.h"
-#include "extensions/browser/view_type_utils.h"
-#include "extensions/common/draggable_region.h"
-#include "extensions/common/extension.h"
-#include "extensions/common/manifest_handlers/icons_handler.h"
-#include "extensions/common/permissions/permissions_data.h"
-#include "extensions/common/switches.h"
-#include "third_party/skia/include/core/SkRegion.h"
-#include "ui/gfx/screen.h"
-
-#if !defined(OS_MACOSX)
-#include "base/prefs/pref_service.h"
-#include "extensions/browser/pref_names.h"
-#endif
-
-using content::BrowserContext;
-using content::ConsoleMessageLevel;
-using content::WebContents;
-using extensions::APIPermission;
-using extensions::NativeAppWindow;
-using web_modal::WebContentsModalDialogHost;
-using web_modal::WebContentsModalDialogManager;
-
-namespace apps {
-
-namespace {
-
-const int kDefaultWidth = 512;
-const int kDefaultHeight = 384;
-
-void SetConstraintProperty(const std::string& name,
-                           int value,
-                           base::DictionaryValue* bounds_properties) {
-  if (value != extensions::SizeConstraints::kUnboundedSize)
-    bounds_properties->SetInteger(name, value);
-  else
-    bounds_properties->Set(name, base::Value::CreateNullValue());
-}
-
-void SetBoundsProperties(const gfx::Rect& bounds,
-                         const gfx::Size& min_size,
-                         const gfx::Size& max_size,
-                         const std::string& bounds_name,
-                         base::DictionaryValue* window_properties) {
-  scoped_ptr<base::DictionaryValue> bounds_properties(
-      new base::DictionaryValue());
-
-  bounds_properties->SetInteger("left", bounds.x());
-  bounds_properties->SetInteger("top", bounds.y());
-  bounds_properties->SetInteger("width", bounds.width());
-  bounds_properties->SetInteger("height", bounds.height());
-
-  SetConstraintProperty("minWidth", min_size.width(), bounds_properties.get());
-  SetConstraintProperty(
-      "minHeight", min_size.height(), bounds_properties.get());
-  SetConstraintProperty("maxWidth", max_size.width(), bounds_properties.get());
-  SetConstraintProperty(
-      "maxHeight", max_size.height(), bounds_properties.get());
-
-  window_properties->Set(bounds_name, bounds_properties.release());
-}
-
-// Combines the constraints of the content and window, and returns constraints
-// for the window.
-gfx::Size GetCombinedWindowConstraints(const gfx::Size& window_constraints,
-                                       const gfx::Size& content_constraints,
-                                       const gfx::Insets& frame_insets) {
-  gfx::Size combined_constraints(window_constraints);
-  if (content_constraints.width() > 0) {
-    combined_constraints.set_width(
-        content_constraints.width() + frame_insets.width());
-  }
-  if (content_constraints.height() > 0) {
-    combined_constraints.set_height(
-        content_constraints.height() + frame_insets.height());
-  }
-  return combined_constraints;
-}
-
-// Combines the constraints of the content and window, and returns constraints
-// for the content.
-gfx::Size GetCombinedContentConstraints(const gfx::Size& window_constraints,
-                                        const gfx::Size& content_constraints,
-                                        const gfx::Insets& frame_insets) {
-  gfx::Size combined_constraints(content_constraints);
-  if (window_constraints.width() > 0) {
-    combined_constraints.set_width(
-        std::max(0, window_constraints.width() - frame_insets.width()));
-  }
-  if (window_constraints.height() > 0) {
-    combined_constraints.set_height(
-        std::max(0, window_constraints.height() - frame_insets.height()));
-  }
-  return combined_constraints;
-}
-
-}  // namespace
-
-// AppWindow::BoundsSpecification
-
-const int AppWindow::BoundsSpecification::kUnspecifiedPosition = INT_MIN;
-
-AppWindow::BoundsSpecification::BoundsSpecification()
-    : bounds(kUnspecifiedPosition, kUnspecifiedPosition, 0, 0) {}
-
-AppWindow::BoundsSpecification::~BoundsSpecification() {}
-
-void AppWindow::BoundsSpecification::ResetBounds() {
-  bounds.SetRect(kUnspecifiedPosition, kUnspecifiedPosition, 0, 0);
-}
-
-// AppWindow::CreateParams
-
-AppWindow::CreateParams::CreateParams()
-    : window_type(AppWindow::WINDOW_TYPE_DEFAULT),
-      frame(AppWindow::FRAME_CHROME),
-      has_frame_color(false),
-      active_frame_color(SK_ColorBLACK),
-      inactive_frame_color(SK_ColorBLACK),
-      alpha_enabled(false),
-      creator_process_id(0),
-      state(ui::SHOW_STATE_DEFAULT),
-      hidden(false),
-      resizable(true),
-      focused(true),
-      always_on_top(false) {
-}
-
-AppWindow::CreateParams::~CreateParams() {}
-
-gfx::Rect AppWindow::CreateParams::GetInitialWindowBounds(
-    const gfx::Insets& frame_insets) const {
-  // Combine into a single window bounds.
-  gfx::Rect combined_bounds(window_spec.bounds);
-  if (content_spec.bounds.x() != BoundsSpecification::kUnspecifiedPosition)
-    combined_bounds.set_x(content_spec.bounds.x() - frame_insets.left());
-  if (content_spec.bounds.y() != BoundsSpecification::kUnspecifiedPosition)
-    combined_bounds.set_y(content_spec.bounds.y() - frame_insets.top());
-  if (content_spec.bounds.width() > 0) {
-    combined_bounds.set_width(
-        content_spec.bounds.width() + frame_insets.width());
-  }
-  if (content_spec.bounds.height() > 0) {
-    combined_bounds.set_height(
-        content_spec.bounds.height() + frame_insets.height());
-  }
-
-  // Constrain the bounds.
-  extensions::SizeConstraints constraints(
-      GetCombinedWindowConstraints(
-          window_spec.minimum_size, content_spec.minimum_size, frame_insets),
-      GetCombinedWindowConstraints(
-          window_spec.maximum_size, content_spec.maximum_size, frame_insets));
-  combined_bounds.set_size(constraints.ClampSize(combined_bounds.size()));
-
-  return combined_bounds;
-}
-
-gfx::Size AppWindow::CreateParams::GetContentMinimumSize(
-    const gfx::Insets& frame_insets) const {
-  return GetCombinedContentConstraints(window_spec.minimum_size,
-                                       content_spec.minimum_size,
-                                       frame_insets);
-}
-
-gfx::Size AppWindow::CreateParams::GetContentMaximumSize(
-    const gfx::Insets& frame_insets) const {
-  return GetCombinedContentConstraints(window_spec.maximum_size,
-                                       content_spec.maximum_size,
-                                       frame_insets);
-}
-
-gfx::Size AppWindow::CreateParams::GetWindowMinimumSize(
-    const gfx::Insets& frame_insets) const {
-  return GetCombinedWindowConstraints(window_spec.minimum_size,
-                                      content_spec.minimum_size,
-                                      frame_insets);
-}
-
-gfx::Size AppWindow::CreateParams::GetWindowMaximumSize(
-    const gfx::Insets& frame_insets) const {
-  return GetCombinedWindowConstraints(window_spec.maximum_size,
-                                      content_spec.maximum_size,
-                                      frame_insets);
-}
-
-// AppWindow
-
-AppWindow::AppWindow(BrowserContext* context,
-                     extensions::AppDelegate* app_delegate,
-                     const extensions::Extension* extension)
-    : browser_context_(context),
-      extension_id_(extension->id()),
-      window_type_(WINDOW_TYPE_DEFAULT),
-      app_delegate_(app_delegate),
-      image_loader_ptr_factory_(this),
-      fullscreen_types_(FULLSCREEN_TYPE_NONE),
-      show_on_first_paint_(false),
-      first_paint_complete_(false),
-      has_been_shown_(false),
-      can_send_events_(false),
-      is_hidden_(false),
-      cached_always_on_top_(false),
-      requested_alpha_enabled_(false) {
-  extensions::ExtensionsBrowserClient* client =
-      extensions::ExtensionsBrowserClient::Get();
-  CHECK(!client->IsGuestSession(context) || context->IsOffTheRecord())
-      << "Only off the record window may be opened in the guest mode.";
-}
-
-void AppWindow::Init(const GURL& url,
-                     AppWindowContents* app_window_contents,
-                     const CreateParams& params) {
-  // Initialize the render interface and web contents
-  app_window_contents_.reset(app_window_contents);
-  app_window_contents_->Initialize(browser_context(), url);
-  WebContents* web_contents = app_window_contents_->GetWebContents();
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          extensions::switches::kEnableAppsShowOnFirstPaint)) {
-    content::WebContentsObserver::Observe(web_contents);
-  }
-  app_delegate_->InitWebContents(web_contents);
-
-  WebContentsModalDialogManager::CreateForWebContents(web_contents);
-
-  web_contents->SetDelegate(this);
-  WebContentsModalDialogManager::FromWebContents(web_contents)
-      ->SetDelegate(this);
-  extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_WINDOW);
-
-  // Initialize the window
-  CreateParams new_params = LoadDefaults(params);
-  window_type_ = new_params.window_type;
-  window_key_ = new_params.window_key;
-
-  // Windows cannot be always-on-top in fullscreen mode for security reasons.
-  cached_always_on_top_ = new_params.always_on_top;
-  if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
-    new_params.always_on_top = false;
-
-  requested_alpha_enabled_ = new_params.alpha_enabled;
-
-  AppsClient* apps_client = AppsClient::Get();
-  native_app_window_.reset(
-      apps_client->CreateNativeAppWindow(this, new_params));
-
-  helper_.reset(new extensions::AppWebContentsHelper(
-      browser_context_, extension_id_, web_contents, app_delegate_.get()));
-
-  popup_manager_.reset(
-      new web_modal::PopupManager(GetWebContentsModalDialogHost()));
-  popup_manager_->RegisterWith(web_contents);
-
-  // Prevent the browser process from shutting down while this window exists.
-  apps_client->IncrementKeepAliveCount();
-  UpdateExtensionAppIcon();
-  AppWindowRegistry::Get(browser_context_)->AddAppWindow(this);
-
-  if (new_params.hidden) {
-    // Although the window starts hidden by default, calling Hide() here
-    // notifies observers of the window being hidden.
-    Hide();
-  } else {
-    // Panels are not activated by default.
-    Show(window_type_is_panel() || !new_params.focused ? SHOW_INACTIVE
-                                                       : SHOW_ACTIVE);
-  }
-
-  if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
-    Fullscreen();
-  else if (new_params.state == ui::SHOW_STATE_MAXIMIZED)
-    Maximize();
-  else if (new_params.state == ui::SHOW_STATE_MINIMIZED)
-    Minimize();
-
-  OnNativeWindowChanged();
-
-  // When the render view host is changed, the native window needs to know
-  // about it in case it has any setup to do to make the renderer appear
-  // properly. In particular, on Windows, the view's clickthrough region needs
-  // to be set.
-  extensions::ExtensionsBrowserClient* client =
-      extensions::ExtensionsBrowserClient::Get();
-  registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
-                 content::Source<content::BrowserContext>(
-                     client->GetOriginalContext(browser_context_)));
-  // Update the app menu if an ephemeral app becomes installed.
-  registrar_.Add(
-      this,
-      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
-      content::Source<content::BrowserContext>(
-          client->GetOriginalContext(browser_context_)));
-
-  // Close when the browser process is exiting.
-  app_delegate_->SetTerminatingCallback(
-      base::Bind(&NativeAppWindow::Close,
-                 base::Unretained(native_app_window_.get())));
-
-  app_window_contents_->LoadContents(new_params.creator_process_id);
-
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          extensions::switches::kEnableAppsShowOnFirstPaint)) {
-    // We want to show the window only when the content has been painted. For
-    // that to happen, we need to define a size for the content, otherwise the
-    // layout will happen in a 0x0 area.
-    gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
-    gfx::Rect initial_bounds = new_params.GetInitialWindowBounds(frame_insets);
-    initial_bounds.Inset(frame_insets);
-    app_delegate_->ResizeWebContents(web_contents, initial_bounds.size());
-  }
-}
-
-AppWindow::~AppWindow() {
-  // Unregister now to prevent getting notified if we're the last window open.
-  app_delegate_->SetTerminatingCallback(base::Closure());
-
-  // Remove shutdown prevention.
-  AppsClient::Get()->DecrementKeepAliveCount();
-}
-
-void AppWindow::RequestMediaAccessPermission(
-    content::WebContents* web_contents,
-    const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback) {
-  DCHECK_EQ(AppWindow::web_contents(), web_contents);
-  helper_->RequestMediaAccessPermission(request, callback);
-}
-
-WebContents* AppWindow::OpenURLFromTab(WebContents* source,
-                                       const content::OpenURLParams& params) {
-  DCHECK_EQ(web_contents(), source);
-  return helper_->OpenURLFromTab(params);
-}
-
-void AppWindow::AddNewContents(WebContents* source,
-                               WebContents* new_contents,
-                               WindowOpenDisposition disposition,
-                               const gfx::Rect& initial_pos,
-                               bool user_gesture,
-                               bool* was_blocked) {
-  DCHECK(new_contents->GetBrowserContext() == browser_context_);
-  app_delegate_->AddNewContents(browser_context_,
-                                new_contents,
-                                disposition,
-                                initial_pos,
-                                user_gesture,
-                                was_blocked);
-}
-
-bool AppWindow::PreHandleKeyboardEvent(
-    content::WebContents* source,
-    const content::NativeWebKeyboardEvent& event,
-    bool* is_keyboard_shortcut) {
-  const extensions::Extension* extension = GetExtension();
-  if (!extension)
-    return false;
-
-  // Here, we can handle a key event before the content gets it. When we are
-  // fullscreen and it is not forced, we want to allow the user to leave
-  // when ESC is pressed.
-  // However, if the application has the "overrideEscFullscreen" permission, we
-  // should let it override that behavior.
-  // ::HandleKeyboardEvent() will only be called if the KeyEvent's default
-  // action is not prevented.
-  // Thus, we should handle the KeyEvent here only if the permission is not set.
-  if (event.windowsKeyCode == ui::VKEY_ESCAPE && IsFullscreen() &&
-      !IsForcedFullscreen() &&
-      !extension->permissions_data()->HasAPIPermission(
-          APIPermission::kOverrideEscFullscreen)) {
-    Restore();
-    return true;
-  }
-
-  return false;
-}
-
-void AppWindow::HandleKeyboardEvent(
-    WebContents* source,
-    const content::NativeWebKeyboardEvent& event) {
-  // If the window is currently fullscreen and not forced, ESC should leave
-  // fullscreen.  If this code is being called for ESC, that means that the
-  // KeyEvent's default behavior was not prevented by the content.
-  if (event.windowsKeyCode == ui::VKEY_ESCAPE && IsFullscreen() &&
-      !IsForcedFullscreen()) {
-    Restore();
-    return;
-  }
-
-  native_app_window_->HandleKeyboardEvent(event);
-}
-
-void AppWindow::RequestToLockMouse(WebContents* web_contents,
-                                   bool user_gesture,
-                                   bool last_unlocked_by_target) {
-  DCHECK_EQ(AppWindow::web_contents(), web_contents);
-  helper_->RequestToLockMouse();
-}
-
-bool AppWindow::PreHandleGestureEvent(WebContents* source,
-                                      const blink::WebGestureEvent& event) {
-  return extensions::AppWebContentsHelper::ShouldSuppressGestureEvent(event);
-}
-
-void AppWindow::DidFirstVisuallyNonEmptyPaint() {
-  first_paint_complete_ = true;
-  if (show_on_first_paint_) {
-    DCHECK(delayed_show_type_ == SHOW_ACTIVE ||
-           delayed_show_type_ == SHOW_INACTIVE);
-    Show(delayed_show_type_);
-  }
-}
-
-void AppWindow::OnNativeClose() {
-  AppWindowRegistry::Get(browser_context_)->RemoveAppWindow(this);
-  if (app_window_contents_) {
-    WebContents* web_contents = app_window_contents_->GetWebContents();
-    WebContentsModalDialogManager::FromWebContents(web_contents)
-        ->SetDelegate(NULL);
-    app_window_contents_->NativeWindowClosed();
-  }
-  delete this;
-}
-
-void AppWindow::OnNativeWindowChanged() {
-  SaveWindowPosition();
-
-#if defined(OS_WIN)
-  if (native_app_window_ && cached_always_on_top_ && !IsFullscreen() &&
-      !native_app_window_->IsMaximized() &&
-      !native_app_window_->IsMinimized()) {
-    UpdateNativeAlwaysOnTop();
-  }
-#endif
-
-  if (app_window_contents_ && native_app_window_)
-    app_window_contents_->NativeWindowChanged(native_app_window_.get());
-}
-
-void AppWindow::OnNativeWindowActivated() {
-  AppWindowRegistry::Get(browser_context_)->AppWindowActivated(this);
-}
-
-content::WebContents* AppWindow::web_contents() const {
-  return app_window_contents_->GetWebContents();
-}
-
-const extensions::Extension* AppWindow::GetExtension() const {
-  return extensions::ExtensionRegistry::Get(browser_context_)
-      ->enabled_extensions()
-      .GetByID(extension_id_);
-}
-
-NativeAppWindow* AppWindow::GetBaseWindow() { return native_app_window_.get(); }
-
-gfx::NativeWindow AppWindow::GetNativeWindow() {
-  return GetBaseWindow()->GetNativeWindow();
-}
-
-gfx::Rect AppWindow::GetClientBounds() const {
-  gfx::Rect bounds = native_app_window_->GetBounds();
-  bounds.Inset(native_app_window_->GetFrameInsets());
-  return bounds;
-}
-
-base::string16 AppWindow::GetTitle() const {
-  const extensions::Extension* extension = GetExtension();
-  if (!extension)
-    return base::string16();
-
-  // WebContents::GetTitle() will return the page's URL if there's no <title>
-  // specified. However, we'd prefer to show the name of the extension in that
-  // case, so we directly inspect the NavigationEntry's title.
-  base::string16 title;
-  if (!web_contents() || !web_contents()->GetController().GetActiveEntry() ||
-      web_contents()->GetController().GetActiveEntry()->GetTitle().empty()) {
-    title = base::UTF8ToUTF16(extension->name());
-  } else {
-    title = web_contents()->GetTitle();
-  }
-  base::RemoveChars(title, base::ASCIIToUTF16("\n"), &title);
-  return title;
-}
-
-void AppWindow::SetAppIconUrl(const GURL& url) {
-  // If the same url is being used for the badge, ignore it.
-  if (url == badge_icon_url_)
-    return;
-
-  // Avoid using any previous icons that were being downloaded.
-  image_loader_ptr_factory_.InvalidateWeakPtrs();
-
-  // Reset |app_icon_image_| to abort pending image load (if any).
-  app_icon_image_.reset();
-
-  app_icon_url_ = url;
-  web_contents()->DownloadImage(
-      url,
-      true,  // is a favicon
-      0,     // no maximum size
-      base::Bind(&AppWindow::DidDownloadFavicon,
-                 image_loader_ptr_factory_.GetWeakPtr()));
-}
-
-void AppWindow::SetBadgeIconUrl(const GURL& url) {
-  // Avoid using any previous icons that were being downloaded.
-  image_loader_ptr_factory_.InvalidateWeakPtrs();
-
-  // Reset |app_icon_image_| to abort pending image load (if any).
-  badge_icon_image_.reset();
-
-  badge_icon_url_ = url;
-  web_contents()->DownloadImage(
-      url,
-      true,  // is a favicon
-      0,     // no maximum size
-      base::Bind(&AppWindow::DidDownloadFavicon,
-                 image_loader_ptr_factory_.GetWeakPtr()));
-}
-
-void AppWindow::ClearBadge() {
-  badge_icon_image_.reset();
-  badge_icon_url_ = GURL();
-  UpdateBadgeIcon(gfx::Image());
-}
-
-void AppWindow::UpdateShape(scoped_ptr<SkRegion> region) {
-  native_app_window_->UpdateShape(region.Pass());
-}
-
-void AppWindow::UpdateDraggableRegions(
-    const std::vector<extensions::DraggableRegion>& regions) {
-  native_app_window_->UpdateDraggableRegions(regions);
-}
-
-void AppWindow::UpdateAppIcon(const gfx::Image& image) {
-  if (image.IsEmpty())
-    return;
-  app_icon_ = image;
-  native_app_window_->UpdateWindowIcon();
-  AppWindowRegistry::Get(browser_context_)->AppWindowIconChanged(this);
-}
-
-void AppWindow::SetFullscreen(FullscreenType type, bool enable) {
-  DCHECK_NE(FULLSCREEN_TYPE_NONE, type);
-
-  if (enable) {
-#if !defined(OS_MACOSX)
-    // Do not enter fullscreen mode if disallowed by pref.
-    // TODO(bartfab): Add a test once it becomes possible to simulate a user
-    // gesture. http://crbug.com/174178
-    if (type != FULLSCREEN_TYPE_FORCED) {
-      PrefService* prefs =
-          extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
-              browser_context());
-      if (!prefs->GetBoolean(extensions::pref_names::kAppFullscreenAllowed))
-        return;
-    }
-#endif
-    fullscreen_types_ |= type;
-  } else {
-    fullscreen_types_ &= ~type;
-  }
-  SetNativeWindowFullscreen();
-}
-
-bool AppWindow::IsFullscreen() const {
-  return fullscreen_types_ != FULLSCREEN_TYPE_NONE;
-}
-
-bool AppWindow::IsForcedFullscreen() const {
-  return (fullscreen_types_ & FULLSCREEN_TYPE_FORCED) != 0;
-}
-
-bool AppWindow::IsHtmlApiFullscreen() const {
-  return (fullscreen_types_ & FULLSCREEN_TYPE_HTML_API) != 0;
-}
-
-void AppWindow::Fullscreen() {
-  SetFullscreen(FULLSCREEN_TYPE_WINDOW_API, true);
-}
-
-void AppWindow::Maximize() { GetBaseWindow()->Maximize(); }
-
-void AppWindow::Minimize() { GetBaseWindow()->Minimize(); }
-
-void AppWindow::Restore() {
-  if (IsFullscreen()) {
-    fullscreen_types_ = FULLSCREEN_TYPE_NONE;
-    SetNativeWindowFullscreen();
-  } else {
-    GetBaseWindow()->Restore();
-  }
-}
-
-void AppWindow::OSFullscreen() {
-  SetFullscreen(FULLSCREEN_TYPE_OS, true);
-}
-
-void AppWindow::ForcedFullscreen() {
-  SetFullscreen(FULLSCREEN_TYPE_FORCED, true);
-}
-
-void AppWindow::SetContentSizeConstraints(const gfx::Size& min_size,
-                                          const gfx::Size& max_size) {
-  extensions::SizeConstraints constraints(min_size, max_size);
-  native_app_window_->SetContentSizeConstraints(constraints.GetMinimumSize(),
-                                                constraints.GetMaximumSize());
-
-  gfx::Rect bounds = GetClientBounds();
-  gfx::Size constrained_size = constraints.ClampSize(bounds.size());
-  if (bounds.size() != constrained_size) {
-    bounds.set_size(constrained_size);
-    bounds.Inset(-native_app_window_->GetFrameInsets());
-    native_app_window_->SetBounds(bounds);
-  }
-  OnNativeWindowChanged();
-}
-
-void AppWindow::Show(ShowType show_type) {
-  is_hidden_ = false;
-
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          extensions::switches::kEnableAppsShowOnFirstPaint)) {
-    show_on_first_paint_ = true;
-
-    if (!first_paint_complete_) {
-      delayed_show_type_ = show_type;
-      return;
-    }
-  }
-
-  switch (show_type) {
-    case SHOW_ACTIVE:
-      GetBaseWindow()->Show();
-      break;
-    case SHOW_INACTIVE:
-      GetBaseWindow()->ShowInactive();
-      break;
-  }
-  AppWindowRegistry::Get(browser_context_)->AppWindowShown(this);
-
-  has_been_shown_ = true;
-  SendOnWindowShownIfShown();
-}
-
-void AppWindow::Hide() {
-  // This is there to prevent race conditions with Hide() being called before
-  // there was a non-empty paint. It should have no effect in a non-racy
-  // scenario where the application is hiding then showing a window: the second
-  // show will not be delayed.
-  is_hidden_ = true;
-  show_on_first_paint_ = false;
-  GetBaseWindow()->Hide();
-  AppWindowRegistry::Get(browser_context_)->AppWindowHidden(this);
-}
-
-void AppWindow::SetAlwaysOnTop(bool always_on_top) {
-  if (cached_always_on_top_ == always_on_top)
-    return;
-
-  cached_always_on_top_ = always_on_top;
-
-  // As a security measure, do not allow fullscreen windows or windows that
-  // overlap the taskbar to be on top. The property will be applied when the
-  // window exits fullscreen and moves away from the taskbar.
-  if (!IsFullscreen() && !IntersectsWithTaskbar())
-    native_app_window_->SetAlwaysOnTop(always_on_top);
-
-  OnNativeWindowChanged();
-}
-
-bool AppWindow::IsAlwaysOnTop() const { return cached_always_on_top_; }
-
-void AppWindow::WindowEventsReady() {
-  can_send_events_ = true;
-  SendOnWindowShownIfShown();
-}
-
-void AppWindow::GetSerializedState(base::DictionaryValue* properties) const {
-  DCHECK(properties);
-
-  properties->SetBoolean("fullscreen",
-                         native_app_window_->IsFullscreenOrPending());
-  properties->SetBoolean("minimized", native_app_window_->IsMinimized());
-  properties->SetBoolean("maximized", native_app_window_->IsMaximized());
-  properties->SetBoolean("alwaysOnTop", IsAlwaysOnTop());
-  properties->SetBoolean("hasFrameColor", native_app_window_->HasFrameColor());
-  properties->SetBoolean(
-      "alphaEnabled",
-      requested_alpha_enabled_ && native_app_window_->CanHaveAlphaEnabled());
-
-  // These properties are undocumented and are to enable testing. Alpha is
-  // removed to
-  // make the values easier to check.
-  SkColor transparent_white = ~SK_ColorBLACK;
-  properties->SetInteger(
-      "activeFrameColor",
-      native_app_window_->ActiveFrameColor() & transparent_white);
-  properties->SetInteger(
-      "inactiveFrameColor",
-      native_app_window_->InactiveFrameColor() & transparent_white);
-
-  gfx::Rect content_bounds = GetClientBounds();
-  gfx::Size content_min_size = native_app_window_->GetContentMinimumSize();
-  gfx::Size content_max_size = native_app_window_->GetContentMaximumSize();
-  SetBoundsProperties(content_bounds,
-                      content_min_size,
-                      content_max_size,
-                      "innerBounds",
-                      properties);
-
-  gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
-  gfx::Rect frame_bounds = native_app_window_->GetBounds();
-  gfx::Size frame_min_size = extensions::SizeConstraints::AddFrameToConstraints(
-      content_min_size, frame_insets);
-  gfx::Size frame_max_size = extensions::SizeConstraints::AddFrameToConstraints(
-      content_max_size, frame_insets);
-  SetBoundsProperties(frame_bounds,
-                      frame_min_size,
-                      frame_max_size,
-                      "outerBounds",
-                      properties);
-}
-
-//------------------------------------------------------------------------------
-// Private methods
-
-void AppWindow::UpdateBadgeIcon(const gfx::Image& image) {
-  badge_icon_ = image;
-  native_app_window_->UpdateBadgeIcon();
-}
-
-void AppWindow::DidDownloadFavicon(
-    int id,
-    int http_status_code,
-    const GURL& image_url,
-    const std::vector<SkBitmap>& bitmaps,
-    const std::vector<gfx::Size>& original_bitmap_sizes) {
-  if ((image_url != app_icon_url_ && image_url != badge_icon_url_) ||
-      bitmaps.empty()) {
-    return;
-  }
-
-  // Bitmaps are ordered largest to smallest. Choose the smallest bitmap
-  // whose height >= the preferred size.
-  int largest_index = 0;
-  for (size_t i = 1; i < bitmaps.size(); ++i) {
-    if (bitmaps[i].height() < app_delegate_->PreferredIconSize())
-      break;
-    largest_index = i;
-  }
-  const SkBitmap& largest = bitmaps[largest_index];
-  if (image_url == app_icon_url_) {
-    UpdateAppIcon(gfx::Image::CreateFrom1xBitmap(largest));
-    return;
-  }
-
-  UpdateBadgeIcon(gfx::Image::CreateFrom1xBitmap(largest));
-}
-
-void AppWindow::OnExtensionIconImageChanged(extensions::IconImage* image) {
-  DCHECK_EQ(app_icon_image_.get(), image);
-
-  UpdateAppIcon(gfx::Image(app_icon_image_->image_skia()));
-}
-
-void AppWindow::UpdateExtensionAppIcon() {
-  // Avoid using any previous app icons were being downloaded.
-  image_loader_ptr_factory_.InvalidateWeakPtrs();
-
-  const extensions::Extension* extension = GetExtension();
-  if (!extension)
-    return;
-
-  app_icon_image_.reset(
-      new extensions::IconImage(browser_context(),
-                                extension,
-                                extensions::IconsInfo::GetIcons(extension),
-                                app_delegate_->PreferredIconSize(),
-                                app_delegate_->GetAppDefaultIcon(),
-                                this));
-
-  // Triggers actual image loading with 1x resources. The 2x resource will
-  // be handled by IconImage class when requested.
-  app_icon_image_->image_skia().GetRepresentation(1.0f);
-}
-
-void AppWindow::SetNativeWindowFullscreen() {
-  native_app_window_->SetFullscreen(fullscreen_types_);
-
-  if (cached_always_on_top_)
-    UpdateNativeAlwaysOnTop();
-}
-
-bool AppWindow::IntersectsWithTaskbar() const {
-#if defined(OS_WIN)
-  gfx::Screen* screen = gfx::Screen::GetNativeScreen();
-  gfx::Rect window_bounds = native_app_window_->GetRestoredBounds();
-  std::vector<gfx::Display> displays = screen->GetAllDisplays();
-
-  for (std::vector<gfx::Display>::const_iterator it = displays.begin();
-       it != displays.end();
-       ++it) {
-    gfx::Rect taskbar_bounds = it->bounds();
-    taskbar_bounds.Subtract(it->work_area());
-    if (taskbar_bounds.IsEmpty())
-      continue;
-
-    if (window_bounds.Intersects(taskbar_bounds))
-      return true;
-  }
-#endif
-
-  return false;
-}
-
-void AppWindow::UpdateNativeAlwaysOnTop() {
-  DCHECK(cached_always_on_top_);
-  bool is_on_top = native_app_window_->IsAlwaysOnTop();
-  bool fullscreen = IsFullscreen();
-  bool intersects_taskbar = IntersectsWithTaskbar();
-
-  if (is_on_top && (fullscreen || intersects_taskbar)) {
-    // When entering fullscreen or overlapping the taskbar, ensure windows are
-    // not always-on-top.
-    native_app_window_->SetAlwaysOnTop(false);
-  } else if (!is_on_top && !fullscreen && !intersects_taskbar) {
-    // When exiting fullscreen and moving away from the taskbar, reinstate
-    // always-on-top.
-    native_app_window_->SetAlwaysOnTop(true);
-  }
-}
-
-void AppWindow::SendOnWindowShownIfShown() {
-  if (!can_send_events_ || !has_been_shown_)
-    return;
-
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
-    app_window_contents_->DispatchWindowShownForTests();
-  }
-}
-
-void AppWindow::CloseContents(WebContents* contents) {
-  native_app_window_->Close();
-}
-
-bool AppWindow::ShouldSuppressDialogs() { return true; }
-
-content::ColorChooser* AppWindow::OpenColorChooser(
-    WebContents* web_contents,
-    SkColor initial_color,
-    const std::vector<content::ColorSuggestion>& suggestions) {
-  return app_delegate_->ShowColorChooser(web_contents, initial_color);
-}
-
-void AppWindow::RunFileChooser(WebContents* tab,
-                               const content::FileChooserParams& params) {
-  if (window_type_is_panel()) {
-    // Panels can't host a file dialog, abort. TODO(stevenjb): allow file
-    // dialogs to be unhosted but still close with the owning web contents.
-    // crbug.com/172502.
-    LOG(WARNING) << "File dialog opened by panel.";
-    return;
-  }
-
-  app_delegate_->RunFileChooser(tab, params);
-}
-
-bool AppWindow::IsPopupOrPanel(const WebContents* source) const { return true; }
-
-void AppWindow::MoveContents(WebContents* source, const gfx::Rect& pos) {
-  native_app_window_->SetBounds(pos);
-}
-
-void AppWindow::NavigationStateChanged(const content::WebContents* source,
-                                       content::InvalidateTypes changed_flags) {
-  if (changed_flags & content::INVALIDATE_TYPE_TITLE)
-    native_app_window_->UpdateWindowTitle();
-  else if (changed_flags & content::INVALIDATE_TYPE_TAB)
-    native_app_window_->UpdateWindowIcon();
-}
-
-void AppWindow::ToggleFullscreenModeForTab(content::WebContents* source,
-                                           bool enter_fullscreen) {
-  const extensions::Extension* extension = GetExtension();
-  if (!extension)
-    return;
-
-  if (!IsExtensionWithPermissionOrSuggestInConsole(
-          APIPermission::kFullscreen, extension, source->GetRenderViewHost())) {
-    return;
-  }
-
-  SetFullscreen(FULLSCREEN_TYPE_HTML_API, enter_fullscreen);
-}
-
-bool AppWindow::IsFullscreenForTabOrPending(const content::WebContents* source)
-    const {
-  return IsHtmlApiFullscreen();
-}
-
-void AppWindow::Observe(int type,
-                        const content::NotificationSource& source,
-                        const content::NotificationDetails& details) {
-  switch (type) {
-    case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
-      const extensions::Extension* unloaded_extension =
-          content::Details<extensions::UnloadedExtensionInfo>(details)
-              ->extension;
-      if (extension_id_ == unloaded_extension->id())
-        native_app_window_->Close();
-      break;
-    }
-    case extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
-      const extensions::Extension* installed_extension =
-          content::Details<const extensions::InstalledExtensionInfo>(details)
-              ->extension;
-      DCHECK(installed_extension);
-      if (installed_extension->id() == extension_id())
-        native_app_window_->UpdateShelfMenu();
-      break;
-    }
-    default:
-      NOTREACHED() << "Received unexpected notification";
-  }
-}
-
-void AppWindow::SetWebContentsBlocked(content::WebContents* web_contents,
-                                      bool blocked) {
-  app_delegate_->SetWebContentsBlocked(web_contents, blocked);
-}
-
-bool AppWindow::IsWebContentsVisible(content::WebContents* web_contents) {
-  return app_delegate_->IsWebContentsVisible(web_contents);
-}
-
-WebContentsModalDialogHost* AppWindow::GetWebContentsModalDialogHost() {
-  return native_app_window_.get();
-}
-
-void AppWindow::SaveWindowPosition() {
-  if (window_key_.empty())
-    return;
-  if (!native_app_window_)
-    return;
-
-  extensions::AppWindowGeometryCache* cache =
-      extensions::AppWindowGeometryCache::Get(browser_context());
-
-  gfx::Rect bounds = native_app_window_->GetRestoredBounds();
-  gfx::Rect screen_bounds =
-      gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds).work_area();
-  ui::WindowShowState window_state = native_app_window_->GetRestoredState();
-  cache->SaveGeometry(
-      extension_id(), window_key_, bounds, screen_bounds, window_state);
-}
-
-void AppWindow::AdjustBoundsToBeVisibleOnScreen(
-    const gfx::Rect& cached_bounds,
-    const gfx::Rect& cached_screen_bounds,
-    const gfx::Rect& current_screen_bounds,
-    const gfx::Size& minimum_size,
-    gfx::Rect* bounds) const {
-  *bounds = cached_bounds;
-
-  // Reposition and resize the bounds if the cached_screen_bounds is different
-  // from the current screen bounds and the current screen bounds doesn't
-  // completely contain the bounds.
-  if (cached_screen_bounds != current_screen_bounds &&
-      !current_screen_bounds.Contains(cached_bounds)) {
-    bounds->set_width(
-        std::max(minimum_size.width(),
-                 std::min(bounds->width(), current_screen_bounds.width())));
-    bounds->set_height(
-        std::max(minimum_size.height(),
-                 std::min(bounds->height(), current_screen_bounds.height())));
-    bounds->set_x(
-        std::max(current_screen_bounds.x(),
-                 std::min(bounds->x(),
-                          current_screen_bounds.right() - bounds->width())));
-    bounds->set_y(
-        std::max(current_screen_bounds.y(),
-                 std::min(bounds->y(),
-                          current_screen_bounds.bottom() - bounds->height())));
-  }
-}
-
-AppWindow::CreateParams AppWindow::LoadDefaults(CreateParams params)
-    const {
-  // Ensure width and height are specified.
-  if (params.content_spec.bounds.width() == 0 &&
-      params.window_spec.bounds.width() == 0) {
-    params.content_spec.bounds.set_width(kDefaultWidth);
-  }
-  if (params.content_spec.bounds.height() == 0 &&
-      params.window_spec.bounds.height() == 0) {
-    params.content_spec.bounds.set_height(kDefaultHeight);
-  }
-
-  // If left and top are left undefined, the native app window will center
-  // the window on the main screen in a platform-defined manner.
-
-  // Load cached state if it exists.
-  if (!params.window_key.empty()) {
-    extensions::AppWindowGeometryCache* cache =
-        extensions::AppWindowGeometryCache::Get(browser_context());
-
-    gfx::Rect cached_bounds;
-    gfx::Rect cached_screen_bounds;
-    ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
-    if (cache->GetGeometry(extension_id(),
-                           params.window_key,
-                           &cached_bounds,
-                           &cached_screen_bounds,
-                           &cached_state)) {
-      // App window has cached screen bounds, make sure it fits on screen in
-      // case the screen resolution changed.
-      gfx::Screen* screen = gfx::Screen::GetNativeScreen();
-      gfx::Display display = screen->GetDisplayMatching(cached_bounds);
-      gfx::Rect current_screen_bounds = display.work_area();
-      extensions::SizeConstraints constraints(
-          params.GetWindowMinimumSize(gfx::Insets()),
-          params.GetWindowMaximumSize(gfx::Insets()));
-      AdjustBoundsToBeVisibleOnScreen(cached_bounds,
-                                      cached_screen_bounds,
-                                      current_screen_bounds,
-                                      constraints.GetMinimumSize(),
-                                      &params.window_spec.bounds);
-      params.state = cached_state;
-
-      // Since we are restoring a cached state, reset the content bounds spec to
-      // ensure it is not used.
-      params.content_spec.ResetBounds();
-    }
-  }
-
-  return params;
-}
-
-// static
-SkRegion* AppWindow::RawDraggableRegionsToSkRegion(
-    const std::vector<extensions::DraggableRegion>& regions) {
-  SkRegion* sk_region = new SkRegion;
-  for (std::vector<extensions::DraggableRegion>::const_iterator iter =
-           regions.begin();
-       iter != regions.end();
-       ++iter) {
-    const extensions::DraggableRegion& region = *iter;
-    sk_region->op(
-        region.bounds.x(),
-        region.bounds.y(),
-        region.bounds.right(),
-        region.bounds.bottom(),
-        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
-  }
-  return sk_region;
-}
-
-}  // namespace apps