apps/shell_window.cc

   1 // Copyright 2013 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/shell_window.h"
   6
   7 #include "apps/native_app_window.h"
   8 #include "apps/shell_window_geometry_cache.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/values.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/extensions/extension_process_manager.h"
  14 #include "chrome/browser/extensions/extension_system.h"
  15 #include "chrome/browser/extensions/shell_window_registry.h"
  16 #include "chrome/browser/extensions/suggest_permission_util.h"
  17 #include "chrome/browser/lifetime/application_lifetime.h"
  18 #include "chrome/browser/profiles/profile.h"
  19 #include "chrome/common/extensions/extension.h"
  20 #include "chrome/common/extensions/extension_constants.h"
  21 #include "chrome/common/extensions/extension_messages.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/invalidate_type.h"
  25 #include "content/public/browser/navigation_entry.h"
  26 #include "content/public/browser/notification_details.h"
  27 #include "content/public/browser/notification_service.h"
  28 #include "content/public/browser/notification_source.h"
  29 #include "content/public/browser/notification_types.h"
  30 #include "content/public/browser/render_view_host.h"
  31 #include "content/public/browser/resource_dispatcher_host.h"
  32 #include "content/public/browser/web_contents.h"
  33 #include "content/public/common/media_stream_request.h"
  34 #include "extensions/browser/view_type_utils.h"
  35 #include "skia/ext/image_operations.h"
  36 #include "third_party/skia/include/core/SkRegion.h"
  37 #include "ui/gfx/image/image_skia.h"
  38 #include "ui/gfx/screen.h"
  39
  40 using content::ConsoleMessageLevel;
  41 using content::WebContents;
  42 using extensions::APIPermission;
  43 using web_modal::WebContentsModalDialogHost;
  44 using web_modal::WebContentsModalDialogManager;
  45
  46 namespace {
  47 const int kDefaultWidth = 512;
  48 const int kDefaultHeight = 384;
  49
  50 }  // namespace
  51
  52 namespace apps {
  53
  54 ShellWindow::CreateParams::CreateParams()
  55   : window_type(ShellWindow::WINDOW_TYPE_DEFAULT),
  56     frame(ShellWindow::FRAME_CHROME),
  57     transparent_background(false),
  58     bounds(INT_MIN, INT_MIN, 0, 0),
  59     creator_process_id(0),
  60     state(ui::SHOW_STATE_DEFAULT),
  61     hidden(false),
  62     resizable(true),
  63     focused(true) {}
  64
  65 ShellWindow::CreateParams::~CreateParams() {}
  66
  67 ShellWindow::Delegate::~Delegate() {}
  68
  69 ShellWindow::ShellWindow(Profile* profile,
  70                          Delegate* delegate,
  71                          const extensions::Extension* extension)
  72     : profile_(profile),
  73       extension_(extension),
  74       extension_id_(extension->id()),
  75       window_type_(WINDOW_TYPE_DEFAULT),
  76       delegate_(delegate),
  77       image_loader_ptr_factory_(this),
  78       fullscreen_for_window_api_(false),
  79       fullscreen_for_tab_(false) {
  80 }
  81
  82 void ShellWindow::Init(const GURL& url,
  83                        ShellWindowContents* shell_window_contents,
  84                        const CreateParams& params) {
  85   // Initialize the render interface and web contents
  86   shell_window_contents_.reset(shell_window_contents);
  87   shell_window_contents_->Initialize(profile(), url);
  88   WebContents* web_contents = shell_window_contents_->GetWebContents();
  89   delegate_->InitWebContents(web_contents);
  90   WebContentsModalDialogManager::CreateForWebContents(web_contents);
  91
  92   web_contents->SetDelegate(this);
  93   WebContentsModalDialogManager::FromWebContents(web_contents)->
  94       set_delegate(this);
  95   extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_SHELL);
  96
  97   // Initialize the window
  98   window_type_ = params.window_type;
  99
 100   gfx::Rect bounds = params.bounds;
 101
 102   if (bounds.width() == 0)
 103     bounds.set_width(kDefaultWidth);
 104   if (bounds.height() == 0)
 105     bounds.set_height(kDefaultHeight);
 106
 107   // If left and top are left undefined, the native shell window will center
 108   // the window on the main screen in a platform-defined manner.
 109
 110   CreateParams new_params = params;
 111
 112   // Load cached state if it exists.
 113   if (!params.window_key.empty()) {
 114     window_key_ = params.window_key;
 115
 116     ShellWindowGeometryCache* cache = ShellWindowGeometryCache::Get(profile());
 117
 118     gfx::Rect cached_bounds;
 119     gfx::Rect cached_screen_bounds;
 120     ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
 121     if (cache->GetGeometry(extension()->id(), params.window_key, &cached_bounds,
 122                            &cached_screen_bounds, &cached_state)) {
 123       // App window has cached screen bounds, make sure it fits on screen in
 124       // case the screen resolution changed.
 125       gfx::Screen* screen = gfx::Screen::GetNativeScreen();
 126       gfx::Display display = screen->GetDisplayMatching(cached_bounds);
 127       gfx::Rect current_screen_bounds = display.work_area();
 128       AdjustBoundsToBeVisibleOnScreen(cached_bounds,
 129                                       cached_screen_bounds,
 130                                       current_screen_bounds,
 131                                       params.minimum_size,
 132                                       &bounds);
 133       new_params.state = cached_state;
 134     }
 135   }
 136
 137   gfx::Size& minimum_size = new_params.minimum_size;
 138   gfx::Size& maximum_size = new_params.maximum_size;
 139
 140   // In the case that minimum size > maximum size, we consider the minimum
 141   // size to be more important.
 142   if (maximum_size.width() && maximum_size.width() < minimum_size.width())
 143     maximum_size.set_width(minimum_size.width());
 144   if (maximum_size.height() && maximum_size.height() < minimum_size.height())
 145     maximum_size.set_height(minimum_size.height());
 146
 147   if (maximum_size.width() && bounds.width() > maximum_size.width())
 148     bounds.set_width(maximum_size.width());
 149   if (bounds.width() != INT_MIN && bounds.width() < minimum_size.width())
 150     bounds.set_width(minimum_size.width());
 151
 152   if (maximum_size.height() && bounds.height() > maximum_size.height())
 153     bounds.set_height(maximum_size.height());
 154   if (bounds.height() != INT_MIN && bounds.height() < minimum_size.height())
 155     bounds.set_height(minimum_size.height());
 156
 157   new_params.bounds = bounds;
 158
 159   native_app_window_.reset(delegate_->CreateNativeAppWindow(this, new_params));
 160
 161   if (!new_params.hidden) {
 162     if (window_type_is_panel())
 163       GetBaseWindow()->ShowInactive();  // Panels are not activated by default.
 164     else
 165       GetBaseWindow()->Show();
 166   }
 167
 168   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
 169     Fullscreen();
 170   else if (new_params.state == ui::SHOW_STATE_MAXIMIZED)
 171     Maximize();
 172   else if (new_params.state == ui::SHOW_STATE_MINIMIZED)
 173     Minimize();
 174
 175   OnNativeWindowChanged();
 176
 177   // When the render view host is changed, the native window needs to know
 178   // about it in case it has any setup to do to make the renderer appear
 179   // properly. In particular, on Windows, the view's clickthrough region needs
 180   // to be set.
 181   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
 182                  content::Source<content::NavigationController>(
 183                     &web_contents->GetController()));
 184   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
 185                  content::Source<Profile>(profile_));
 186   // Close when the browser process is exiting.
 187   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
 188                  content::NotificationService::AllSources());
 189
 190   shell_window_contents_->LoadContents(params.creator_process_id);
 191
 192   // Prevent the browser process from shutting down while this window is open.
 193   chrome::StartKeepAlive();
 194
 195   UpdateExtensionAppIcon();
 196
 197   extensions::ShellWindowRegistry::Get(profile_)->AddShellWindow(this);
 198 }
 199
 200 ShellWindow::~ShellWindow() {
 201   // Unregister now to prevent getting NOTIFICATION_APP_TERMINATING if we're the
 202   // last window open.
 203   registrar_.RemoveAll();
 204
 205   // Remove shutdown prevention.
 206   chrome::EndKeepAlive();
 207 }
 208
 209 void ShellWindow::RequestMediaAccessPermission(
 210     content::WebContents* web_contents,
 211     const content::MediaStreamRequest& request,
 212     const content::MediaResponseCallback& callback) {
 213   delegate_->RequestMediaAccessPermission(web_contents, request, callback,
 214                                           extension());
 215 }
 216
 217 WebContents* ShellWindow::OpenURLFromTab(WebContents* source,
 218                                          const content::OpenURLParams& params) {
 219   // Don't allow the current tab to be navigated. It would be nice to map all
 220   // anchor tags (even those without target="_blank") to new tabs, but right
 221   // now we can't distinguish between those and <meta> refreshes or window.href
 222   // navigations, which we don't want to allow.
 223   // TOOD(mihaip): Can we check for user gestures instead?
 224   WindowOpenDisposition disposition = params.disposition;
 225   if (disposition == CURRENT_TAB) {
 226     AddMessageToDevToolsConsole(
 227         content::CONSOLE_MESSAGE_LEVEL_ERROR,
 228         base::StringPrintf(
 229             "Can't open same-window link to \"%s\"; try target=\"_blank\".",
 230             params.url.spec().c_str()));
 231     return NULL;
 232   }
 233
 234   // These dispositions aren't really navigations.
 235   if (disposition == SUPPRESS_OPEN || disposition == SAVE_TO_DISK ||
 236       disposition == IGNORE_ACTION) {
 237     return NULL;
 238   }
 239
 240   WebContents* contents = delegate_->OpenURLFromTab(profile_, source,
 241                                                     params);
 242   if (!contents) {
 243     AddMessageToDevToolsConsole(
 244         content::CONSOLE_MESSAGE_LEVEL_ERROR,
 245         base::StringPrintf(
 246             "Can't navigate to \"%s\"; apps do not support navigation.",
 247             params.url.spec().c_str()));
 248   }
 249
 250   return contents;
 251 }
 252
 253 void ShellWindow::AddNewContents(WebContents* source,
 254                                  WebContents* new_contents,
 255                                  WindowOpenDisposition disposition,
 256                                  const gfx::Rect& initial_pos,
 257                                  bool user_gesture,
 258                                  bool* was_blocked) {
 259   DCHECK(Profile::FromBrowserContext(new_contents->GetBrowserContext()) ==
 260       profile_);
 261   delegate_->AddNewContents(profile_, new_contents, disposition,
 262                             initial_pos, user_gesture, was_blocked);
 263 }
 264
 265 void ShellWindow::HandleKeyboardEvent(
 266     WebContents* source,
 267     const content::NativeWebKeyboardEvent& event) {
 268   native_app_window_->HandleKeyboardEvent(event);
 269 }
 270
 271 void ShellWindow::RequestToLockMouse(WebContents* web_contents,
 272                                      bool user_gesture,
 273                                      bool last_unlocked_by_target) {
 274   bool has_permission = IsExtensionWithPermissionOrSuggestInConsole(
 275       APIPermission::kPointerLock,
 276       extension_,
 277       web_contents->GetRenderViewHost());
 278
 279   web_contents->GotResponseToLockMouseRequest(has_permission);
 280 }
 281
 282 void ShellWindow::OnNativeClose() {
 283   extensions::ShellWindowRegistry::Get(profile_)->RemoveShellWindow(this);
 284   if (shell_window_contents_)
 285     shell_window_contents_->NativeWindowClosed();
 286   delete this;
 287 }
 288
 289 void ShellWindow::OnNativeWindowChanged() {
 290   SaveWindowPosition();
 291   if (shell_window_contents_ && native_app_window_)
 292     shell_window_contents_->NativeWindowChanged(native_app_window_.get());
 293 }
 294
 295 void ShellWindow::OnNativeWindowActivated() {
 296   extensions::ShellWindowRegistry::Get(profile_)->ShellWindowActivated(this);
 297 }
 298
 299 scoped_ptr<gfx::Image> ShellWindow::GetAppListIcon() {
 300   // TODO(skuhne): We might want to use LoadImages in UpdateExtensionAppIcon
 301   // instead to let the extension give us pre-defined icons in the launcher
 302   // and the launcher list sizes. Since there is no mock yet, doing this now
 303   // seems a bit premature and we scale for the time being.
 304   if (app_icon_.IsEmpty())
 305     return make_scoped_ptr(new gfx::Image());
 306
 307   SkBitmap bmp = skia::ImageOperations::Resize(
 308         *app_icon_.ToSkBitmap(), skia::ImageOperations::RESIZE_BEST,
 309         extension_misc::EXTENSION_ICON_SMALLISH,
 310         extension_misc::EXTENSION_ICON_SMALLISH);
 311   return make_scoped_ptr(
 312       new gfx::Image(gfx::ImageSkia::CreateFrom1xBitmap(bmp)));
 313 }
 314
 315 content::WebContents* ShellWindow::web_contents() const {
 316   return shell_window_contents_->GetWebContents();
 317 }
 318
 319 NativeAppWindow* ShellWindow::GetBaseWindow() {
 320   return native_app_window_.get();
 321 }
 322
 323 gfx::NativeWindow ShellWindow::GetNativeWindow() {
 324   return GetBaseWindow()->GetNativeWindow();
 325 }
 326
 327 gfx::Rect ShellWindow::GetClientBounds() const {
 328   gfx::Rect bounds = native_app_window_->GetBounds();
 329   bounds.Inset(native_app_window_->GetFrameInsets());
 330   return bounds;
 331 }
 332
 333 string16 ShellWindow::GetTitle() const {
 334   // WebContents::GetTitle() will return the page's URL if there's no <title>
 335   // specified. However, we'd prefer to show the name of the extension in that
 336   // case, so we directly inspect the NavigationEntry's title.
 337   string16 title;
 338   if (!web_contents() ||
 339       !web_contents()->GetController().GetActiveEntry() ||
 340       web_contents()->GetController().GetActiveEntry()->GetTitle().empty()) {
 341     title = UTF8ToUTF16(extension()->name());
 342   } else {
 343     title = web_contents()->GetTitle();
 344   }
 345   const char16 kBadChars[] = { '\n', 0 };
 346   RemoveChars(title, kBadChars, &title);
 347   return title;
 348 }
 349
 350 void ShellWindow::SetAppIconUrl(const GURL& url) {
 351   // Avoid using any previous app icons were are being downloaded.
 352   image_loader_ptr_factory_.InvalidateWeakPtrs();
 353
 354   // Reset |app_icon_image_| to abort pending image load (if any).
 355   app_icon_image_.reset();
 356
 357   app_icon_url_ = url;
 358   web_contents()->DownloadImage(
 359       url,
 360       true,  // is a favicon
 361       delegate_->PreferredIconSize(),
 362       0,  // no maximum size
 363       base::Bind(&ShellWindow::DidDownloadFavicon,
 364                  image_loader_ptr_factory_.GetWeakPtr()));
 365 }
 366
 367 void ShellWindow::UpdateDraggableRegions(
 368     const std::vector<extensions::DraggableRegion>& regions) {
 369   native_app_window_->UpdateDraggableRegions(regions);
 370 }
 371
 372 void ShellWindow::UpdateAppIcon(const gfx::Image& image) {
 373   if (image.IsEmpty())
 374     return;
 375   app_icon_ = image;
 376   native_app_window_->UpdateWindowIcon();
 377   extensions::ShellWindowRegistry::Get(profile_)->ShellWindowIconChanged(this);
 378 }
 379
 380 void ShellWindow::Fullscreen() {
 381   fullscreen_for_window_api_ = true;
 382   GetBaseWindow()->SetFullscreen(true);
 383 }
 384
 385 void ShellWindow::Maximize() {
 386   GetBaseWindow()->Maximize();
 387 }
 388
 389 void ShellWindow::Minimize() {
 390   GetBaseWindow()->Minimize();
 391 }
 392
 393 void ShellWindow::Restore() {
 394   fullscreen_for_window_api_ = false;
 395   fullscreen_for_tab_ = false;
 396   if (GetBaseWindow()->IsFullscreenOrPending()) {
 397     GetBaseWindow()->SetFullscreen(false);
 398   } else {
 399     GetBaseWindow()->Restore();
 400   }
 401 }
 402
 403 //------------------------------------------------------------------------------
 404 // Private methods
 405
 406 void ShellWindow::DidDownloadFavicon(int id,
 407                                      int http_status_code,
 408                                      const GURL& image_url,
 409                                      int requested_size,
 410                                      const std::vector<SkBitmap>& bitmaps) {
 411   if (image_url != app_icon_url_ || bitmaps.empty())
 412     return;
 413
 414   // Bitmaps are ordered largest to smallest. Choose the smallest bitmap
 415   // whose height >= the preferred size.
 416   int largest_index = 0;
 417   for (size_t i = 1; i < bitmaps.size(); ++i) {
 418     if (bitmaps[i].height() < delegate_->PreferredIconSize())
 419       break;
 420     largest_index = i;
 421   }
 422   const SkBitmap& largest = bitmaps[largest_index];
 423   UpdateAppIcon(gfx::Image::CreateFrom1xBitmap(largest));
 424 }
 425
 426 void ShellWindow::OnExtensionIconImageChanged(extensions::IconImage* image) {
 427   DCHECK_EQ(app_icon_image_.get(), image);
 428
 429   UpdateAppIcon(gfx::Image(app_icon_image_->image_skia()));
 430 }
 431
 432 void ShellWindow::UpdateExtensionAppIcon() {
 433   // Avoid using any previous app icons were are being downloaded.
 434   image_loader_ptr_factory_.InvalidateWeakPtrs();
 435
 436   app_icon_image_.reset(new extensions::IconImage(
 437       profile(),
 438       extension(),
 439       extensions::IconsInfo::GetIcons(extension()),
 440       delegate_->PreferredIconSize(),
 441       extensions::IconsInfo::GetDefaultAppIcon(),
 442       this));
 443
 444   // Triggers actual image loading with 1x resources. The 2x resource will
 445   // be handled by IconImage class when requested.
 446   app_icon_image_->image_skia().GetRepresentation(ui::SCALE_FACTOR_100P);
 447 }
 448
 449 void ShellWindow::CloseContents(WebContents* contents) {
 450   native_app_window_->Close();
 451 }
 452
 453 bool ShellWindow::ShouldSuppressDialogs() {
 454   return true;
 455 }
 456
 457 content::ColorChooser* ShellWindow::OpenColorChooser(WebContents* web_contents,
 458                                                      SkColor initial_color) {
 459   return delegate_->ShowColorChooser(web_contents, initial_color);
 460 }
 461
 462 void ShellWindow::RunFileChooser(WebContents* tab,
 463                                  const content::FileChooserParams& params) {
 464   if (window_type_is_panel()) {
 465     // Panels can't host a file dialog, abort. TODO(stevenjb): allow file
 466     // dialogs to be unhosted but still close with the owning web contents.
 467     // crbug.com/172502.
 468     LOG(WARNING) << "File dialog opened by panel.";
 469     return;
 470   }
 471
 472   delegate_->RunFileChooser(tab, params);
 473 }
 474
 475 bool ShellWindow::IsPopupOrPanel(const WebContents* source) const {
 476   return true;
 477 }
 478
 479 void ShellWindow::MoveContents(WebContents* source, const gfx::Rect& pos) {
 480   native_app_window_->SetBounds(pos);
 481 }
 482
 483 void ShellWindow::NavigationStateChanged(
 484     const content::WebContents* source, unsigned changed_flags) {
 485   if (changed_flags & content::INVALIDATE_TYPE_TITLE)
 486     native_app_window_->UpdateWindowTitle();
 487   else if (changed_flags & content::INVALIDATE_TYPE_TAB)
 488     native_app_window_->UpdateWindowIcon();
 489 }
 490
 491 void ShellWindow::ToggleFullscreenModeForTab(content::WebContents* source,
 492                                              bool enter_fullscreen) {
 493   if (!IsExtensionWithPermissionOrSuggestInConsole(
 494       APIPermission::kFullscreen,
 495       extension_,
 496       source->GetRenderViewHost())) {
 497     return;
 498   }
 499
 500   fullscreen_for_tab_ = enter_fullscreen;
 501
 502   if (enter_fullscreen) {
 503     native_app_window_->SetFullscreen(true);
 504   } else if (!fullscreen_for_window_api_) {
 505     native_app_window_->SetFullscreen(false);
 506   }
 507 }
 508
 509 bool ShellWindow::IsFullscreenForTabOrPending(
 510     const content::WebContents* source) const {
 511   return fullscreen_for_tab_;
 512 }
 513
 514 void ShellWindow::Observe(int type,
 515                           const content::NotificationSource& source,
 516                           const content::NotificationDetails& details) {
 517   switch (type) {
 518     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
 519       // TODO(jianli): once http://crbug.com/123007 is fixed, we'll no longer
 520       // need to make the native window (ShellWindowViews specially) update
 521       // the clickthrough region for the new RVH.
 522       native_app_window_->RenderViewHostChanged();
 523       break;
 524     }
 525     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
 526       const extensions::Extension* unloaded_extension =
 527           content::Details<extensions::UnloadedExtensionInfo>(
 528               details)->extension;
 529       if (extension_ == unloaded_extension)
 530         native_app_window_->Close();
 531       break;
 532     }
 533     case chrome::NOTIFICATION_APP_TERMINATING:
 534       native_app_window_->Close();
 535       break;
 536     default:
 537       NOTREACHED() << "Received unexpected notification";
 538   }
 539 }
 540
 541 void ShellWindow::SetWebContentsBlocked(content::WebContents* web_contents,
 542                                         bool blocked) {
 543   delegate_->SetWebContentsBlocked(web_contents, blocked);
 544 }
 545
 546 bool ShellWindow::IsWebContentsVisible(content::WebContents* web_contents) {
 547   return delegate_->IsWebContentsVisible(web_contents);
 548 }
 549
 550 extensions::ActiveTabPermissionGranter*
 551     ShellWindow::GetActiveTabPermissionGranter() {
 552   // Shell windows don't support the activeTab permission.
 553   return NULL;
 554 }
 555
 556 WebContentsModalDialogHost* ShellWindow::GetWebContentsModalDialogHost() {
 557   return native_app_window_.get();
 558 }
 559
 560 void ShellWindow::AddMessageToDevToolsConsole(ConsoleMessageLevel level,
 561                                               const std::string& message) {
 562   content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
 563   rvh->Send(new ExtensionMsg_AddMessageToConsole(
 564       rvh->GetRoutingID(), level, message));
 565 }
 566
 567 void ShellWindow::SaveWindowPosition() {
 568   if (window_key_.empty())
 569     return;
 570   if (!native_app_window_)
 571     return;
 572
 573   ShellWindowGeometryCache* cache = ShellWindowGeometryCache::Get(profile());
 574
 575   gfx::Rect bounds = native_app_window_->GetRestoredBounds();
 576   bounds.Inset(native_app_window_->GetFrameInsets());
 577   gfx::Rect screen_bounds =
 578       gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds).work_area();
 579   ui::WindowShowState window_state = native_app_window_->GetRestoredState();
 580   cache->SaveGeometry(extension()->id(),
 581                       window_key_,
 582                       bounds,
 583                       screen_bounds,
 584                       window_state);
 585 }
 586
 587 void ShellWindow::AdjustBoundsToBeVisibleOnScreen(
 588     const gfx::Rect& cached_bounds,
 589     const gfx::Rect& cached_screen_bounds,
 590     const gfx::Rect& current_screen_bounds,
 591     const gfx::Size& minimum_size,
 592     gfx::Rect* bounds) const {
 593   *bounds = cached_bounds;
 594
 595   // Reposition and resize the bounds if the cached_screen_bounds is different
 596   // from the current screen bounds and the current screen bounds doesn't
 597   // completely contain the bounds.
 598   if (cached_screen_bounds != current_screen_bounds &&
 599       !current_screen_bounds.Contains(cached_bounds)) {
 600     bounds->set_width(
 601         std::max(minimum_size.width(),
 602                  std::min(bounds->width(), current_screen_bounds.width())));
 603     bounds->set_height(
 604         std::max(minimum_size.height(),
 605                  std::min(bounds->height(), current_screen_bounds.height())));
 606     bounds->set_x(
 607         std::max(current_screen_bounds.x(),
 608                  std::min(bounds->x(),
 609                           current_screen_bounds.right() - bounds->width())));
 610     bounds->set_y(
 611         std::max(current_screen_bounds.y(),
 612                  std::min(bounds->y(),
 613                           current_screen_bounds.bottom() - bounds->height())));
 614   }
 615 }
 616
 617 // static
 618 SkRegion* ShellWindow::RawDraggableRegionsToSkRegion(
 619       const std::vector<extensions::DraggableRegion>& regions) {
 620   SkRegion* sk_region = new SkRegion;
 621   for (std::vector<extensions::DraggableRegion>::const_iterator iter =
 622            regions.begin();
 623        iter != regions.end(); ++iter) {
 624     const extensions::DraggableRegion& region = *iter;
 625     sk_region->op(
 626         region.bounds.x(),
 627         region.bounds.y(),
 628         region.bounds.right(),
 629         region.bounds.bottom(),
 630         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
 631   }
 632   return sk_region;
 633 }
 634
 635 }  // namespace apps