apps/app_window.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "apps/app_window.h"
   6
   7 #include <algorithm>
   8
   9 #include "apps/app_window_geometry_cache.h"
  10 #include "apps/app_window_registry.h"
  11 #include "apps/apps_client.h"
  12 #include "apps/size_constraints.h"
  13 #include "apps/ui/native_app_window.h"
  14 #include "base/command_line.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/values.h"
  18 #include "chrome/browser/chrome_notification_types.h"
  19 #include "chrome/browser/extensions/extension_web_contents_observer.h"
  20 #include "chrome/browser/extensions/suggest_permission_util.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/common/extensions/manifest_handlers/icons_handler.h"
  23 #include "components/web_modal/web_contents_modal_dialog_manager.h"
  24 #include "content/public/browser/browser_context.h"
  25 #include "content/public/browser/invalidate_type.h"
  26 #include "content/public/browser/navigation_entry.h"
  27 #include "content/public/browser/notification_details.h"
  28 #include "content/public/browser/notification_service.h"
  29 #include "content/public/browser/notification_source.h"
  30 #include "content/public/browser/notification_types.h"
  31 #include "content/public/browser/render_view_host.h"
  32 #include "content/public/browser/resource_dispatcher_host.h"
  33 #include "content/public/browser/web_contents.h"
  34 #include "content/public/browser/web_contents_view.h"
  35 #include "content/public/common/media_stream_request.h"
  36 #include "extensions/browser/extension_system.h"
  37 #include "extensions/browser/extensions_browser_client.h"
  38 #include "extensions/browser/process_manager.h"
  39 #include "extensions/browser/view_type_utils.h"
  40 #include "extensions/common/extension.h"
  41 #include "extensions/common/extension_messages.h"
  42 #include "third_party/skia/include/core/SkRegion.h"
  43 #include "ui/gfx/screen.h"
  44
  45 #if !defined(OS_MACOSX)
  46 #include "apps/pref_names.h"
  47 #include "base/prefs/pref_service.h"
  48 #endif
  49
  50 using content::BrowserContext;
  51 using content::ConsoleMessageLevel;
  52 using content::WebContents;
  53 using extensions::APIPermission;
  54 using web_modal::WebContentsModalDialogHost;
  55 using web_modal::WebContentsModalDialogManager;
  56
  57 namespace apps {
  58
  59 namespace {
  60
  61 const int kDefaultWidth = 512;
  62 const int kDefaultHeight = 384;
  63
  64 bool IsFullscreen(int fullscreen_types) {
  65   return fullscreen_types != apps::AppWindow::FULLSCREEN_TYPE_NONE;
  66 }
  67
  68 void SetConstraintProperty(const std::string& name,
  69                            int value,
  70                            base::DictionaryValue* bounds_properties) {
  71   if (value != SizeConstraints::kUnboundedSize)
  72     bounds_properties->SetInteger(name, value);
  73   else
  74     bounds_properties->Set(name, base::Value::CreateNullValue());
  75 }
  76
  77 void SetBoundsProperties(const gfx::Rect& bounds,
  78                          const gfx::Size& min_size,
  79                          const gfx::Size& max_size,
  80                          const std::string& bounds_name,
  81                          base::DictionaryValue* window_properties) {
  82   scoped_ptr<base::DictionaryValue> bounds_properties(
  83       new base::DictionaryValue());
  84
  85   bounds_properties->SetInteger("left", bounds.x());
  86   bounds_properties->SetInteger("top", bounds.y());
  87   bounds_properties->SetInteger("width", bounds.width());
  88   bounds_properties->SetInteger("height", bounds.height());
  89
  90   SetConstraintProperty("minWidth", min_size.width(), bounds_properties.get());
  91   SetConstraintProperty(
  92       "minHeight", min_size.height(), bounds_properties.get());
  93   SetConstraintProperty("maxWidth", max_size.width(), bounds_properties.get());
  94   SetConstraintProperty(
  95       "maxHeight", max_size.height(), bounds_properties.get());
  96
  97   window_properties->Set(bounds_name, bounds_properties.release());
  98 }
  99
 100 // Combines the constraints of the content and window, and returns constraints
 101 // for the window.
 102 gfx::Size GetCombinedWindowConstraints(const gfx::Size& window_constraints,
 103                                        const gfx::Size& content_constraints,
 104                                        const gfx::Insets& frame_insets) {
 105   gfx::Size combined_constraints(window_constraints);
 106   if (content_constraints.width() > 0) {
 107     combined_constraints.set_width(
 108         content_constraints.width() + frame_insets.width());
 109   }
 110   if (content_constraints.height() > 0) {
 111     combined_constraints.set_height(
 112         content_constraints.height() + frame_insets.height());
 113   }
 114   return combined_constraints;
 115 }
 116
 117 // Combines the constraints of the content and window, and returns constraints
 118 // for the content.
 119 gfx::Size GetCombinedContentConstraints(const gfx::Size& window_constraints,
 120                                         const gfx::Size& content_constraints,
 121                                         const gfx::Insets& frame_insets) {
 122   gfx::Size combined_constraints(content_constraints);
 123   if (window_constraints.width() > 0) {
 124     combined_constraints.set_width(
 125         std::max(0, window_constraints.width() - frame_insets.width()));
 126   }
 127   if (window_constraints.height() > 0) {
 128     combined_constraints.set_height(
 129         std::max(0, window_constraints.height() - frame_insets.height()));
 130   }
 131   return combined_constraints;
 132 }
 133
 134 }  // namespace
 135
 136 // AppWindow::BoundsSpecification
 137
 138 const int AppWindow::BoundsSpecification::kUnspecifiedPosition = INT_MIN;
 139
 140 AppWindow::BoundsSpecification::BoundsSpecification()
 141     : bounds(kUnspecifiedPosition, kUnspecifiedPosition, 0, 0) {}
 142
 143 AppWindow::BoundsSpecification::~BoundsSpecification() {}
 144
 145 void AppWindow::BoundsSpecification::ResetBounds() {
 146   bounds.SetRect(kUnspecifiedPosition, kUnspecifiedPosition, 0, 0);
 147 }
 148
 149 // AppWindow::CreateParams
 150
 151 AppWindow::CreateParams::CreateParams()
 152     : window_type(AppWindow::WINDOW_TYPE_DEFAULT),
 153       frame(AppWindow::FRAME_CHROME),
 154       has_frame_color(false),
 155       transparent_background(false),
 156       creator_process_id(0),
 157       state(ui::SHOW_STATE_DEFAULT),
 158       hidden(false),
 159       resizable(true),
 160       focused(true),
 161       always_on_top(false) {}
 162
 163 AppWindow::CreateParams::~CreateParams() {}
 164
 165 gfx::Rect AppWindow::CreateParams::GetInitialWindowBounds(
 166     const gfx::Insets& frame_insets) const {
 167   // Combine into a single window bounds.
 168   gfx::Rect combined_bounds(window_spec.bounds);
 169   if (content_spec.bounds.x() != BoundsSpecification::kUnspecifiedPosition)
 170     combined_bounds.set_x(content_spec.bounds.x() - frame_insets.left());
 171   if (content_spec.bounds.y() != BoundsSpecification::kUnspecifiedPosition)
 172     combined_bounds.set_y(content_spec.bounds.y() - frame_insets.top());
 173   if (content_spec.bounds.width() > 0) {
 174     combined_bounds.set_width(
 175         content_spec.bounds.width() + frame_insets.width());
 176   }
 177   if (content_spec.bounds.height() > 0) {
 178     combined_bounds.set_height(
 179         content_spec.bounds.height() + frame_insets.height());
 180   }
 181
 182   // Constrain the bounds.
 183   SizeConstraints constraints(
 184       GetCombinedWindowConstraints(
 185           window_spec.minimum_size, content_spec.minimum_size, frame_insets),
 186       GetCombinedWindowConstraints(
 187           window_spec.maximum_size, content_spec.maximum_size, frame_insets));
 188   combined_bounds.set_size(constraints.ClampSize(combined_bounds.size()));
 189
 190   return combined_bounds;
 191 }
 192
 193 gfx::Size AppWindow::CreateParams::GetContentMinimumSize(
 194     const gfx::Insets& frame_insets) const {
 195   return GetCombinedContentConstraints(window_spec.minimum_size,
 196                                        content_spec.minimum_size,
 197                                        frame_insets);
 198 }
 199
 200 gfx::Size AppWindow::CreateParams::GetContentMaximumSize(
 201     const gfx::Insets& frame_insets) const {
 202   return GetCombinedContentConstraints(window_spec.maximum_size,
 203                                        content_spec.maximum_size,
 204                                        frame_insets);
 205 }
 206
 207 gfx::Size AppWindow::CreateParams::GetWindowMinimumSize(
 208     const gfx::Insets& frame_insets) const {
 209   return GetCombinedWindowConstraints(window_spec.minimum_size,
 210                                       content_spec.minimum_size,
 211                                       frame_insets);
 212 }
 213
 214 gfx::Size AppWindow::CreateParams::GetWindowMaximumSize(
 215     const gfx::Insets& frame_insets) const {
 216   return GetCombinedWindowConstraints(window_spec.maximum_size,
 217                                       content_spec.maximum_size,
 218                                       frame_insets);
 219 }
 220
 221 // AppWindow::Delegate
 222
 223 AppWindow::Delegate::~Delegate() {}
 224
 225 // AppWindow
 226
 227 AppWindow::AppWindow(BrowserContext* context,
 228                      Delegate* delegate,
 229                      const extensions::Extension* extension)
 230     : browser_context_(context),
 231       extension_(extension),
 232       extension_id_(extension->id()),
 233       window_type_(WINDOW_TYPE_DEFAULT),
 234       delegate_(delegate),
 235       image_loader_ptr_factory_(this),
 236       fullscreen_types_(FULLSCREEN_TYPE_NONE),
 237       show_on_first_paint_(false),
 238       first_paint_complete_(false),
 239       cached_always_on_top_(false) {
 240   extensions::ExtensionsBrowserClient* client =
 241       extensions::ExtensionsBrowserClient::Get();
 242   CHECK(!client->IsGuestSession(context) || context->IsOffTheRecord())
 243       << "Only off the record window may be opened in the guest mode.";
 244 }
 245
 246 void AppWindow::Init(const GURL& url,
 247                      AppWindowContents* app_window_contents,
 248                      const CreateParams& params) {
 249   // Initialize the render interface and web contents
 250   app_window_contents_.reset(app_window_contents);
 251   app_window_contents_->Initialize(browser_context(), url);
 252   WebContents* web_contents = app_window_contents_->GetWebContents();
 253   if (CommandLine::ForCurrentProcess()->HasSwitch(
 254           switches::kEnableAppsShowOnFirstPaint)) {
 255     content::WebContentsObserver::Observe(web_contents);
 256   }
 257   delegate_->InitWebContents(web_contents);
 258   WebContentsModalDialogManager::CreateForWebContents(web_contents);
 259   extensions::ExtensionWebContentsObserver::CreateForWebContents(web_contents);
 260
 261   web_contents->SetDelegate(this);
 262   WebContentsModalDialogManager::FromWebContents(web_contents)
 263       ->SetDelegate(this);
 264   extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_WINDOW);
 265
 266   // Initialize the window
 267   CreateParams new_params = LoadDefaults(params);
 268   window_type_ = new_params.window_type;
 269   window_key_ = new_params.window_key;
 270
 271   // Windows cannot be always-on-top in fullscreen mode for security reasons.
 272   cached_always_on_top_ = new_params.always_on_top;
 273   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
 274     new_params.always_on_top = false;
 275
 276   native_app_window_.reset(delegate_->CreateNativeAppWindow(this, new_params));
 277
 278   if (!new_params.hidden) {
 279     // Panels are not activated by default.
 280     Show(window_type_is_panel() || !new_params.focused ? SHOW_INACTIVE
 281                                                        : SHOW_ACTIVE);
 282   }
 283
 284   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
 285     Fullscreen();
 286   else if (new_params.state == ui::SHOW_STATE_MAXIMIZED)
 287     Maximize();
 288   else if (new_params.state == ui::SHOW_STATE_MINIMIZED)
 289     Minimize();
 290
 291   OnNativeWindowChanged();
 292
 293   // When the render view host is changed, the native window needs to know
 294   // about it in case it has any setup to do to make the renderer appear
 295   // properly. In particular, on Windows, the view's clickthrough region needs
 296   // to be set.
 297   extensions::ExtensionsBrowserClient* client =
 298       extensions::ExtensionsBrowserClient::Get();
 299   registrar_.Add(this,
 300                  chrome::NOTIFICATION_EXTENSION_UNLOADED,
 301                  content::Source<content::BrowserContext>(
 302                      client->GetOriginalContext(browser_context_)));
 303   // Close when the browser process is exiting.
 304   registrar_.Add(this,
 305                  chrome::NOTIFICATION_APP_TERMINATING,
 306                  content::NotificationService::AllSources());
 307   // Update the app menu if an ephemeral app becomes installed.
 308   registrar_.Add(this,
 309                  chrome::NOTIFICATION_EXTENSION_INSTALLED,
 310                  content::Source<content::BrowserContext>(
 311                      client->GetOriginalContext(browser_context_)));
 312
 313   app_window_contents_->LoadContents(new_params.creator_process_id);
 314
 315   if (CommandLine::ForCurrentProcess()->HasSwitch(
 316           switches::kEnableAppsShowOnFirstPaint)) {
 317     // We want to show the window only when the content has been painted. For
 318     // that to happen, we need to define a size for the content, otherwise the
 319     // layout will happen in a 0x0 area.
 320     // Note: WebContents::GetView() is guaranteed to be non-null.
 321     gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
 322     gfx::Rect initial_bounds = new_params.GetInitialWindowBounds(frame_insets);
 323     initial_bounds.Inset(frame_insets);
 324     web_contents->GetView()->SizeContents(initial_bounds.size());
 325   }
 326
 327   // Prevent the browser process from shutting down while this window is open.
 328   AppsClient::Get()->IncrementKeepAliveCount();
 329
 330   UpdateExtensionAppIcon();
 331
 332   AppWindowRegistry::Get(browser_context_)->AddAppWindow(this);
 333 }
 334
 335 AppWindow::~AppWindow() {
 336   // Unregister now to prevent getting NOTIFICATION_APP_TERMINATING if we're the
 337   // last window open.
 338   registrar_.RemoveAll();
 339
 340   // Remove shutdown prevention.
 341   AppsClient::Get()->DecrementKeepAliveCount();
 342 }
 343
 344 void AppWindow::RequestMediaAccessPermission(
 345     content::WebContents* web_contents,
 346     const content::MediaStreamRequest& request,
 347     const content::MediaResponseCallback& callback) {
 348   delegate_->RequestMediaAccessPermission(
 349       web_contents, request, callback, extension());
 350 }
 351
 352 WebContents* AppWindow::OpenURLFromTab(WebContents* source,
 353                                        const content::OpenURLParams& params) {
 354   // Don't allow the current tab to be navigated. It would be nice to map all
 355   // anchor tags (even those without target="_blank") to new tabs, but right
 356   // now we can't distinguish between those and <meta> refreshes or window.href
 357   // navigations, which we don't want to allow.
 358   // TOOD(mihaip): Can we check for user gestures instead?
 359   WindowOpenDisposition disposition = params.disposition;
 360   if (disposition == CURRENT_TAB) {
 361     AddMessageToDevToolsConsole(
 362         content::CONSOLE_MESSAGE_LEVEL_ERROR,
 363         base::StringPrintf(
 364             "Can't open same-window link to \"%s\"; try target=\"_blank\".",
 365             params.url.spec().c_str()));
 366     return NULL;
 367   }
 368
 369   // These dispositions aren't really navigations.
 370   if (disposition == SUPPRESS_OPEN || disposition == SAVE_TO_DISK ||
 371       disposition == IGNORE_ACTION) {
 372     return NULL;
 373   }
 374
 375   WebContents* contents =
 376       delegate_->OpenURLFromTab(browser_context_, source, params);
 377   if (!contents) {
 378     AddMessageToDevToolsConsole(
 379         content::CONSOLE_MESSAGE_LEVEL_ERROR,
 380         base::StringPrintf(
 381             "Can't navigate to \"%s\"; apps do not support navigation.",
 382             params.url.spec().c_str()));
 383   }
 384
 385   return contents;
 386 }
 387
 388 void AppWindow::AddNewContents(WebContents* source,
 389                                WebContents* new_contents,
 390                                WindowOpenDisposition disposition,
 391                                const gfx::Rect& initial_pos,
 392                                bool user_gesture,
 393                                bool* was_blocked) {
 394   DCHECK(new_contents->GetBrowserContext() == browser_context_);
 395   delegate_->AddNewContents(browser_context_,
 396                             new_contents,
 397                             disposition,
 398                             initial_pos,
 399                             user_gesture,
 400                             was_blocked);
 401 }
 402
 403 bool AppWindow::PreHandleKeyboardEvent(
 404     content::WebContents* source,
 405     const content::NativeWebKeyboardEvent& event,
 406     bool* is_keyboard_shortcut) {
 407   // Here, we can handle a key event before the content gets it. When we are
 408   // fullscreen and it is not forced, we want to allow the user to leave
 409   // when ESC is pressed.
 410   // However, if the application has the "overrideEscFullscreen" permission, we
 411   // should let it override that behavior.
 412   // ::HandleKeyboardEvent() will only be called if the KeyEvent's default
 413   // action is not prevented.
 414   // Thus, we should handle the KeyEvent here only if the permission is not set.
 415   if (event.windowsKeyCode == ui::VKEY_ESCAPE &&
 416       (fullscreen_types_ != FULLSCREEN_TYPE_NONE) &&
 417       ((fullscreen_types_ & FULLSCREEN_TYPE_FORCED) == 0) &&
 418       !extension_->HasAPIPermission(APIPermission::kOverrideEscFullscreen)) {
 419     Restore();
 420     return true;
 421   }
 422
 423   return false;
 424 }
 425
 426 void AppWindow::HandleKeyboardEvent(
 427     WebContents* source,
 428     const content::NativeWebKeyboardEvent& event) {
 429   // If the window is currently fullscreen and not forced, ESC should leave
 430   // fullscreen.  If this code is being called for ESC, that means that the
 431   // KeyEvent's default behavior was not prevented by the content.
 432   if (event.windowsKeyCode == ui::VKEY_ESCAPE &&
 433       (fullscreen_types_ != FULLSCREEN_TYPE_NONE) &&
 434       ((fullscreen_types_ & FULLSCREEN_TYPE_FORCED) == 0)) {
 435     Restore();
 436     return;
 437   }
 438
 439   native_app_window_->HandleKeyboardEvent(event);
 440 }
 441
 442 void AppWindow::RequestToLockMouse(WebContents* web_contents,
 443                                    bool user_gesture,
 444                                    bool last_unlocked_by_target) {
 445   bool has_permission = IsExtensionWithPermissionOrSuggestInConsole(
 446       APIPermission::kPointerLock,
 447       extension_,
 448       web_contents->GetRenderViewHost());
 449
 450   web_contents->GotResponseToLockMouseRequest(has_permission);
 451 }
 452
 453 bool AppWindow::PreHandleGestureEvent(WebContents* source,
 454                                       const blink::WebGestureEvent& event) {
 455   // Disable pinch zooming in app windows.
 456   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
 457          event.type == blink::WebGestureEvent::GesturePinchUpdate ||
 458          event.type == blink::WebGestureEvent::GesturePinchEnd;
 459 }
 460
 461 void AppWindow::DidFirstVisuallyNonEmptyPaint(int32 page_id) {
 462   first_paint_complete_ = true;
 463   if (show_on_first_paint_) {
 464     DCHECK(delayed_show_type_ == SHOW_ACTIVE ||
 465            delayed_show_type_ == SHOW_INACTIVE);
 466     Show(delayed_show_type_);
 467   }
 468 }
 469
 470 void AppWindow::OnNativeClose() {
 471   AppWindowRegistry::Get(browser_context_)->RemoveAppWindow(this);
 472   if (app_window_contents_) {
 473     WebContents* web_contents = app_window_contents_->GetWebContents();
 474     WebContentsModalDialogManager::FromWebContents(web_contents)
 475         ->SetDelegate(NULL);
 476     app_window_contents_->NativeWindowClosed();
 477   }
 478   delete this;
 479 }
 480
 481 void AppWindow::OnNativeWindowChanged() {
 482   SaveWindowPosition();
 483
 484 #if defined(OS_WIN)
 485   if (native_app_window_ && cached_always_on_top_ &&
 486       !IsFullscreen(fullscreen_types_) && !native_app_window_->IsMaximized() &&
 487       !native_app_window_->IsMinimized()) {
 488     UpdateNativeAlwaysOnTop();
 489   }
 490 #endif
 491
 492   if (app_window_contents_ && native_app_window_)
 493     app_window_contents_->NativeWindowChanged(native_app_window_.get());
 494 }
 495
 496 void AppWindow::OnNativeWindowActivated() {
 497   AppWindowRegistry::Get(browser_context_)->AppWindowActivated(this);
 498 }
 499
 500 content::WebContents* AppWindow::web_contents() const {
 501   return app_window_contents_->GetWebContents();
 502 }
 503
 504 NativeAppWindow* AppWindow::GetBaseWindow() { return native_app_window_.get(); }
 505
 506 gfx::NativeWindow AppWindow::GetNativeWindow() {
 507   return GetBaseWindow()->GetNativeWindow();
 508 }
 509
 510 gfx::Rect AppWindow::GetClientBounds() const {
 511   gfx::Rect bounds = native_app_window_->GetBounds();
 512   bounds.Inset(native_app_window_->GetFrameInsets());
 513   return bounds;
 514 }
 515
 516 base::string16 AppWindow::GetTitle() const {
 517   // WebContents::GetTitle() will return the page's URL if there's no <title>
 518   // specified. However, we'd prefer to show the name of the extension in that
 519   // case, so we directly inspect the NavigationEntry's title.
 520   base::string16 title;
 521   if (!web_contents() || !web_contents()->GetController().GetActiveEntry() ||
 522       web_contents()->GetController().GetActiveEntry()->GetTitle().empty()) {
 523     title = base::UTF8ToUTF16(extension()->name());
 524   } else {
 525     title = web_contents()->GetTitle();
 526   }
 527   const base::char16 kBadChars[] = {'\n', 0};
 528   base::RemoveChars(title, kBadChars, &title);
 529   return title;
 530 }
 531
 532 void AppWindow::SetAppIconUrl(const GURL& url) {
 533   // If the same url is being used for the badge, ignore it.
 534   if (url == badge_icon_url_)
 535     return;
 536
 537   // Avoid using any previous icons that were being downloaded.
 538   image_loader_ptr_factory_.InvalidateWeakPtrs();
 539
 540   // Reset |app_icon_image_| to abort pending image load (if any).
 541   app_icon_image_.reset();
 542
 543   app_icon_url_ = url;
 544   web_contents()->DownloadImage(
 545       url,
 546       true,  // is a favicon
 547       0,     // no maximum size
 548       base::Bind(&AppWindow::DidDownloadFavicon,
 549                  image_loader_ptr_factory_.GetWeakPtr()));
 550 }
 551
 552 void AppWindow::SetBadgeIconUrl(const GURL& url) {
 553   // Avoid using any previous icons that were being downloaded.
 554   image_loader_ptr_factory_.InvalidateWeakPtrs();
 555
 556   // Reset |app_icon_image_| to abort pending image load (if any).
 557   badge_icon_image_.reset();
 558
 559   badge_icon_url_ = url;
 560   web_contents()->DownloadImage(
 561       url,
 562       true,  // is a favicon
 563       0,     // no maximum size
 564       base::Bind(&AppWindow::DidDownloadFavicon,
 565                  image_loader_ptr_factory_.GetWeakPtr()));
 566 }
 567
 568 void AppWindow::ClearBadge() {
 569   badge_icon_image_.reset();
 570   badge_icon_url_ = GURL();
 571   UpdateBadgeIcon(gfx::Image());
 572 }
 573
 574 void AppWindow::UpdateShape(scoped_ptr<SkRegion> region) {
 575   native_app_window_->UpdateShape(region.Pass());
 576 }
 577
 578 void AppWindow::UpdateDraggableRegions(
 579     const std::vector<extensions::DraggableRegion>& regions) {
 580   native_app_window_->UpdateDraggableRegions(regions);
 581 }
 582
 583 void AppWindow::UpdateAppIcon(const gfx::Image& image) {
 584   if (image.IsEmpty())
 585     return;
 586   app_icon_ = image;
 587   native_app_window_->UpdateWindowIcon();
 588   AppWindowRegistry::Get(browser_context_)->AppWindowIconChanged(this);
 589 }
 590
 591 void AppWindow::Fullscreen() {
 592 #if !defined(OS_MACOSX)
 593   // Do not enter fullscreen mode if disallowed by pref.
 594   PrefService* prefs =
 595       extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
 596           browser_context());
 597   if (!prefs->GetBoolean(prefs::kAppFullscreenAllowed))
 598     return;
 599 #endif
 600   fullscreen_types_ |= FULLSCREEN_TYPE_WINDOW_API;
 601   SetNativeWindowFullscreen();
 602 }
 603
 604 void AppWindow::Maximize() { GetBaseWindow()->Maximize(); }
 605
 606 void AppWindow::Minimize() { GetBaseWindow()->Minimize(); }
 607
 608 void AppWindow::Restore() {
 609   if (IsFullscreen(fullscreen_types_)) {
 610     fullscreen_types_ = FULLSCREEN_TYPE_NONE;
 611     SetNativeWindowFullscreen();
 612   } else {
 613     GetBaseWindow()->Restore();
 614   }
 615 }
 616
 617 void AppWindow::OSFullscreen() {
 618 #if !defined(OS_MACOSX)
 619   // Do not enter fullscreen mode if disallowed by pref.
 620   PrefService* prefs =
 621       extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
 622           browser_context());
 623   if (!prefs->GetBoolean(prefs::kAppFullscreenAllowed))
 624     return;
 625 #endif
 626   fullscreen_types_ |= FULLSCREEN_TYPE_OS;
 627   SetNativeWindowFullscreen();
 628 }
 629
 630 void AppWindow::ForcedFullscreen() {
 631   fullscreen_types_ |= FULLSCREEN_TYPE_FORCED;
 632   SetNativeWindowFullscreen();
 633 }
 634
 635 void AppWindow::SetContentMinimumSize(const gfx::Size& min_size) {
 636   native_app_window_->SetContentMinimumSize(min_size);
 637   OnSizeConstraintsChanged();
 638 }
 639
 640 void AppWindow::SetContentMaximumSize(const gfx::Size& max_size) {
 641   native_app_window_->SetContentMaximumSize(max_size);
 642   OnSizeConstraintsChanged();
 643 }
 644
 645 void AppWindow::Show(ShowType show_type) {
 646   if (CommandLine::ForCurrentProcess()->HasSwitch(
 647           switches::kEnableAppsShowOnFirstPaint)) {
 648     show_on_first_paint_ = true;
 649
 650     if (!first_paint_complete_) {
 651       delayed_show_type_ = show_type;
 652       return;
 653     }
 654   }
 655
 656   switch (show_type) {
 657     case SHOW_ACTIVE:
 658       GetBaseWindow()->Show();
 659       break;
 660     case SHOW_INACTIVE:
 661       GetBaseWindow()->ShowInactive();
 662       break;
 663   }
 664 }
 665
 666 void AppWindow::Hide() {
 667   // This is there to prevent race conditions with Hide() being called before
 668   // there was a non-empty paint. It should have no effect in a non-racy
 669   // scenario where the application is hiding then showing a window: the second
 670   // show will not be delayed.
 671   show_on_first_paint_ = false;
 672   GetBaseWindow()->Hide();
 673 }
 674
 675 void AppWindow::SetAlwaysOnTop(bool always_on_top) {
 676   if (cached_always_on_top_ == always_on_top)
 677     return;
 678
 679   cached_always_on_top_ = always_on_top;
 680
 681   // As a security measure, do not allow fullscreen windows or windows that
 682   // overlap the taskbar to be on top. The property will be applied when the
 683   // window exits fullscreen and moves away from the taskbar.
 684   if (!IsFullscreen(fullscreen_types_) && !IntersectsWithTaskbar())
 685     native_app_window_->SetAlwaysOnTop(always_on_top);
 686
 687   OnNativeWindowChanged();
 688 }
 689
 690 bool AppWindow::IsAlwaysOnTop() const { return cached_always_on_top_; }
 691
 692 void AppWindow::GetSerializedState(base::DictionaryValue* properties) const {
 693   DCHECK(properties);
 694
 695   properties->SetBoolean("fullscreen",
 696                          native_app_window_->IsFullscreenOrPending());
 697   properties->SetBoolean("minimized", native_app_window_->IsMinimized());
 698   properties->SetBoolean("maximized", native_app_window_->IsMaximized());
 699   properties->SetBoolean("alwaysOnTop", IsAlwaysOnTop());
 700   properties->SetBoolean("hasFrameColor", native_app_window_->HasFrameColor());
 701   properties->SetInteger("frameColor", native_app_window_->FrameColor());
 702
 703   gfx::Rect content_bounds = GetClientBounds();
 704   gfx::Size content_min_size = native_app_window_->GetContentMinimumSize();
 705   gfx::Size content_max_size = native_app_window_->GetContentMaximumSize();
 706   SetBoundsProperties(content_bounds,
 707                       content_min_size,
 708                       content_max_size,
 709                       "innerBounds",
 710                       properties);
 711
 712   gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
 713   gfx::Rect frame_bounds = native_app_window_->GetBounds();
 714   gfx::Size frame_min_size =
 715       SizeConstraints::AddFrameToConstraints(content_min_size, frame_insets);
 716   gfx::Size frame_max_size =
 717       SizeConstraints::AddFrameToConstraints(content_max_size, frame_insets);
 718   SetBoundsProperties(frame_bounds,
 719                       frame_min_size,
 720                       frame_max_size,
 721                       "outerBounds",
 722                       properties);
 723 }
 724
 725 //------------------------------------------------------------------------------
 726 // Private methods
 727
 728 void AppWindow::UpdateBadgeIcon(const gfx::Image& image) {
 729   badge_icon_ = image;
 730   native_app_window_->UpdateBadgeIcon();
 731 }
 732
 733 void AppWindow::DidDownloadFavicon(
 734     int id,
 735     int http_status_code,
 736     const GURL& image_url,
 737     const std::vector<SkBitmap>& bitmaps,
 738     const std::vector<gfx::Size>& original_bitmap_sizes) {
 739   if ((image_url != app_icon_url_ && image_url != badge_icon_url_) ||
 740       bitmaps.empty()) {
 741     return;
 742   }
 743
 744   // Bitmaps are ordered largest to smallest. Choose the smallest bitmap
 745   // whose height >= the preferred size.
 746   int largest_index = 0;
 747   for (size_t i = 1; i < bitmaps.size(); ++i) {
 748     if (bitmaps[i].height() < delegate_->PreferredIconSize())
 749       break;
 750     largest_index = i;
 751   }
 752   const SkBitmap& largest = bitmaps[largest_index];
 753   if (image_url == app_icon_url_) {
 754     UpdateAppIcon(gfx::Image::CreateFrom1xBitmap(largest));
 755     return;
 756   }
 757
 758   UpdateBadgeIcon(gfx::Image::CreateFrom1xBitmap(largest));
 759 }
 760
 761 void AppWindow::OnExtensionIconImageChanged(extensions::IconImage* image) {
 762   DCHECK_EQ(app_icon_image_.get(), image);
 763
 764   UpdateAppIcon(gfx::Image(app_icon_image_->image_skia()));
 765 }
 766
 767 void AppWindow::UpdateExtensionAppIcon() {
 768   // Avoid using any previous app icons were being downloaded.
 769   image_loader_ptr_factory_.InvalidateWeakPtrs();
 770
 771   app_icon_image_.reset(
 772       new extensions::IconImage(browser_context(),
 773                                 extension(),
 774                                 extensions::IconsInfo::GetIcons(extension()),
 775                                 delegate_->PreferredIconSize(),
 776                                 extensions::IconsInfo::GetDefaultAppIcon(),
 777                                 this));
 778
 779   // Triggers actual image loading with 1x resources. The 2x resource will
 780   // be handled by IconImage class when requested.
 781   app_icon_image_->image_skia().GetRepresentation(1.0f);
 782 }
 783
 784 void AppWindow::OnSizeConstraintsChanged() {
 785   SizeConstraints size_constraints(native_app_window_->GetContentMinimumSize(),
 786                                    native_app_window_->GetContentMaximumSize());
 787   gfx::Rect bounds = GetClientBounds();
 788   gfx::Size constrained_size = size_constraints.ClampSize(bounds.size());
 789   if (bounds.size() != constrained_size) {
 790     bounds.set_size(constrained_size);
 791     bounds.Inset(-native_app_window_->GetFrameInsets());
 792     native_app_window_->SetBounds(bounds);
 793   }
 794   OnNativeWindowChanged();
 795 }
 796
 797 void AppWindow::SetNativeWindowFullscreen() {
 798   native_app_window_->SetFullscreen(fullscreen_types_);
 799
 800   if (cached_always_on_top_)
 801     UpdateNativeAlwaysOnTop();
 802 }
 803
 804 bool AppWindow::IntersectsWithTaskbar() const {
 805 #if defined(OS_WIN)
 806   gfx::Screen* screen = gfx::Screen::GetNativeScreen();
 807   gfx::Rect window_bounds = native_app_window_->GetRestoredBounds();
 808   std::vector<gfx::Display> displays = screen->GetAllDisplays();
 809
 810   for (std::vector<gfx::Display>::const_iterator it = displays.begin();
 811        it != displays.end();
 812        ++it) {
 813     gfx::Rect taskbar_bounds = it->bounds();
 814     taskbar_bounds.Subtract(it->work_area());
 815     if (taskbar_bounds.IsEmpty())
 816       continue;
 817
 818     if (window_bounds.Intersects(taskbar_bounds))
 819       return true;
 820   }
 821 #endif
 822
 823   return false;
 824 }
 825
 826 void AppWindow::UpdateNativeAlwaysOnTop() {
 827   DCHECK(cached_always_on_top_);
 828   bool is_on_top = native_app_window_->IsAlwaysOnTop();
 829   bool fullscreen = IsFullscreen(fullscreen_types_);
 830   bool intersects_taskbar = IntersectsWithTaskbar();
 831
 832   if (is_on_top && (fullscreen || intersects_taskbar)) {
 833     // When entering fullscreen or overlapping the taskbar, ensure windows are
 834     // not always-on-top.
 835     native_app_window_->SetAlwaysOnTop(false);
 836   } else if (!is_on_top && !fullscreen && !intersects_taskbar) {
 837     // When exiting fullscreen and moving away from the taskbar, reinstate
 838     // always-on-top.
 839     native_app_window_->SetAlwaysOnTop(true);
 840   }
 841 }
 842
 843 void AppWindow::CloseContents(WebContents* contents) {
 844   native_app_window_->Close();
 845 }
 846
 847 bool AppWindow::ShouldSuppressDialogs() { return true; }
 848
 849 content::ColorChooser* AppWindow::OpenColorChooser(
 850     WebContents* web_contents,
 851     SkColor initial_color,
 852     const std::vector<content::ColorSuggestion>& suggestionss) {
 853   return delegate_->ShowColorChooser(web_contents, initial_color);
 854 }
 855
 856 void AppWindow::RunFileChooser(WebContents* tab,
 857                                const content::FileChooserParams& params) {
 858   if (window_type_is_panel()) {
 859     // Panels can't host a file dialog, abort. TODO(stevenjb): allow file
 860     // dialogs to be unhosted but still close with the owning web contents.
 861     // crbug.com/172502.
 862     LOG(WARNING) << "File dialog opened by panel.";
 863     return;
 864   }
 865
 866   delegate_->RunFileChooser(tab, params);
 867 }
 868
 869 bool AppWindow::IsPopupOrPanel(const WebContents* source) const { return true; }
 870
 871 void AppWindow::MoveContents(WebContents* source, const gfx::Rect& pos) {
 872   native_app_window_->SetBounds(pos);
 873 }
 874
 875 void AppWindow::NavigationStateChanged(const content::WebContents* source,
 876                                        unsigned changed_flags) {
 877   if (changed_flags & content::INVALIDATE_TYPE_TITLE)
 878     native_app_window_->UpdateWindowTitle();
 879   else if (changed_flags & content::INVALIDATE_TYPE_TAB)
 880     native_app_window_->UpdateWindowIcon();
 881 }
 882
 883 void AppWindow::ToggleFullscreenModeForTab(content::WebContents* source,
 884                                            bool enter_fullscreen) {
 885 #if !defined(OS_MACOSX)
 886   // Do not enter fullscreen mode if disallowed by pref.
 887   // TODO(bartfab): Add a test once it becomes possible to simulate a user
 888   // gesture. http://crbug.com/174178
 889   PrefService* prefs =
 890       extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
 891           browser_context());
 892   if (enter_fullscreen && !prefs->GetBoolean(prefs::kAppFullscreenAllowed)) {
 893     return;
 894   }
 895 #endif
 896
 897   if (!IsExtensionWithPermissionOrSuggestInConsole(
 898            APIPermission::kFullscreen,
 899            extension_,
 900            source->GetRenderViewHost())) {
 901     return;
 902   }
 903
 904   if (enter_fullscreen)
 905     fullscreen_types_ |= FULLSCREEN_TYPE_HTML_API;
 906   else
 907     fullscreen_types_ &= ~FULLSCREEN_TYPE_HTML_API;
 908   SetNativeWindowFullscreen();
 909 }
 910
 911 bool AppWindow::IsFullscreenForTabOrPending(const content::WebContents* source)
 912     const {
 913   return ((fullscreen_types_ & FULLSCREEN_TYPE_HTML_API) != 0);
 914 }
 915
 916 void AppWindow::Observe(int type,
 917                         const content::NotificationSource& source,
 918                         const content::NotificationDetails& details) {
 919   switch (type) {
 920     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
 921       const extensions::Extension* unloaded_extension =
 922           content::Details<extensions::UnloadedExtensionInfo>(details)
 923               ->extension;
 924       if (extension_ == unloaded_extension)
 925         native_app_window_->Close();
 926       break;
 927     }
 928     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
 929       const extensions::Extension* installed_extension =
 930           content::Details<const extensions::InstalledExtensionInfo>(details)
 931               ->extension;
 932       DCHECK(installed_extension);
 933       if (installed_extension->id() == extension_->id())
 934         native_app_window_->UpdateShelfMenu();
 935       break;
 936     }
 937     case chrome::NOTIFICATION_APP_TERMINATING:
 938       native_app_window_->Close();
 939       break;
 940     default:
 941       NOTREACHED() << "Received unexpected notification";
 942   }
 943 }
 944
 945 void AppWindow::SetWebContentsBlocked(content::WebContents* web_contents,
 946                                       bool blocked) {
 947   delegate_->SetWebContentsBlocked(web_contents, blocked);
 948 }
 949
 950 bool AppWindow::IsWebContentsVisible(content::WebContents* web_contents) {
 951   return delegate_->IsWebContentsVisible(web_contents);
 952 }
 953
 954 WebContentsModalDialogHost* AppWindow::GetWebContentsModalDialogHost() {
 955   return native_app_window_.get();
 956 }
 957
 958 void AppWindow::AddMessageToDevToolsConsole(ConsoleMessageLevel level,
 959                                             const std::string& message) {
 960   content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
 961   rvh->Send(new ExtensionMsg_AddMessageToConsole(
 962       rvh->GetRoutingID(), level, message));
 963 }
 964
 965 void AppWindow::SaveWindowPosition() {
 966   if (window_key_.empty())
 967     return;
 968   if (!native_app_window_)
 969     return;
 970
 971   AppWindowGeometryCache* cache =
 972       AppWindowGeometryCache::Get(browser_context());
 973
 974   gfx::Rect bounds = native_app_window_->GetRestoredBounds();
 975   gfx::Rect screen_bounds =
 976       gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds).work_area();
 977   ui::WindowShowState window_state = native_app_window_->GetRestoredState();
 978   cache->SaveGeometry(
 979       extension()->id(), window_key_, bounds, screen_bounds, window_state);
 980 }
 981
 982 void AppWindow::AdjustBoundsToBeVisibleOnScreen(
 983     const gfx::Rect& cached_bounds,
 984     const gfx::Rect& cached_screen_bounds,
 985     const gfx::Rect& current_screen_bounds,
 986     const gfx::Size& minimum_size,
 987     gfx::Rect* bounds) const {
 988   *bounds = cached_bounds;
 989
 990   // Reposition and resize the bounds if the cached_screen_bounds is different
 991   // from the current screen bounds and the current screen bounds doesn't
 992   // completely contain the bounds.
 993   if (cached_screen_bounds != current_screen_bounds &&
 994       !current_screen_bounds.Contains(cached_bounds)) {
 995     bounds->set_width(
 996         std::max(minimum_size.width(),
 997                  std::min(bounds->width(), current_screen_bounds.width())));
 998     bounds->set_height(
 999         std::max(minimum_size.height(),
1000                  std::min(bounds->height(), current_screen_bounds.height())));
1001     bounds->set_x(
1002         std::max(current_screen_bounds.x(),
1003                  std::min(bounds->x(),
1004                           current_screen_bounds.right() - bounds->width())));
1005     bounds->set_y(
1006         std::max(current_screen_bounds.y(),
1007                  std::min(bounds->y(),
1008                           current_screen_bounds.bottom() - bounds->height())));
1009   }
1010 }
1011
1012 AppWindow::CreateParams AppWindow::LoadDefaults(CreateParams params)
1013     const {
1014   // Ensure width and height are specified.
1015   if (params.content_spec.bounds.width() == 0 &&
1016       params.window_spec.bounds.width() == 0) {
1017     params.content_spec.bounds.set_width(kDefaultWidth);
1018   }
1019   if (params.content_spec.bounds.height() == 0 &&
1020       params.window_spec.bounds.height() == 0) {
1021     params.content_spec.bounds.set_height(kDefaultHeight);
1022   }
1023
1024   // If left and top are left undefined, the native app window will center
1025   // the window on the main screen in a platform-defined manner.
1026
1027   // Load cached state if it exists.
1028   if (!params.window_key.empty()) {
1029     AppWindowGeometryCache* cache =
1030         AppWindowGeometryCache::Get(browser_context());
1031
1032     gfx::Rect cached_bounds;
1033     gfx::Rect cached_screen_bounds;
1034     ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
1035     if (cache->GetGeometry(extension()->id(),
1036                            params.window_key,
1037                            &cached_bounds,
1038                            &cached_screen_bounds,
1039                            &cached_state)) {
1040
1041       // App window has cached screen bounds, make sure it fits on screen in
1042       // case the screen resolution changed.
1043       gfx::Screen* screen = gfx::Screen::GetNativeScreen();
1044       gfx::Display display = screen->GetDisplayMatching(cached_bounds);
1045       gfx::Rect current_screen_bounds = display.work_area();
1046       SizeConstraints constraints(params.GetWindowMinimumSize(gfx::Insets()),
1047                                   params.GetWindowMaximumSize(gfx::Insets()));
1048       AdjustBoundsToBeVisibleOnScreen(cached_bounds,
1049                                       cached_screen_bounds,
1050                                       current_screen_bounds,
1051                                       constraints.GetMinimumSize(),
1052                                       &params.window_spec.bounds);
1053       params.state = cached_state;
1054
1055       // Since we are restoring a cached state, reset the content bounds spec to
1056       // ensure it is not used.
1057       params.content_spec.ResetBounds();
1058     }
1059   }
1060
1061   return params;
1062 }
1063
1064 // static
1065 SkRegion* AppWindow::RawDraggableRegionsToSkRegion(
1066     const std::vector<extensions::DraggableRegion>& regions) {
1067   SkRegion* sk_region = new SkRegion;
1068   for (std::vector<extensions::DraggableRegion>::const_iterator iter =
1069            regions.begin();
1070        iter != regions.end();
1071        ++iter) {
1072     const extensions::DraggableRegion& region = *iter;
1073     sk_region->op(
1074         region.bounds.x(),
1075         region.bounds.y(),
1076         region.bounds.right(),
1077         region.bounds.bottom(),
1078         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
1079   }
1080   return sk_region;
1081 }
1082
1083 }  // namespace apps