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