chrome/browser/ui/panels/panel.cc

   1 // Copyright (c) 2012 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 "chrome/browser/ui/panels/panel.h"
   6
   7 #include "base/logging.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/app/chrome_command_ids.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/devtools/devtools_window.h"
  13 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  14 #include "chrome/browser/extensions/api/tabs/tabs_windows_api.h"
  15 #include "chrome/browser/extensions/api/tabs/windows_event_router.h"
  16 #include "chrome/browser/extensions/extension_service.h"
  17 #include "chrome/browser/extensions/extension_tab_util.h"
  18 #include "chrome/browser/extensions/image_loader.h"
  19 #include "chrome/browser/extensions/window_controller.h"
  20 #include "chrome/browser/extensions/window_controller_list.h"
  21 #include "chrome/browser/lifetime/application_lifetime.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/browser/themes/theme_service.h"
  24 #include "chrome/browser/themes/theme_service_factory.h"
  25 #include "chrome/browser/ui/panels/native_panel.h"
  26 #include "chrome/browser/ui/panels/panel_collection.h"
  27 #include "chrome/browser/ui/panels/panel_host.h"
  28 #include "chrome/browser/ui/panels/panel_manager.h"
  29 #include "chrome/browser/ui/panels/stacked_panel_collection.h"
  30 #include "chrome/browser/web_applications/web_app.h"
  31 #include "content/public/browser/notification_service.h"
  32 #include "content/public/browser/notification_source.h"
  33 #include "content/public/browser/notification_types.h"
  34 #include "content/public/browser/render_view_host.h"
  35 #include "content/public/browser/user_metrics.h"
  36 #include "content/public/browser/web_contents.h"
  37 #include "extensions/browser/extension_system.h"
  38 #include "extensions/common/constants.h"
  39 #include "extensions/common/extension.h"
  40 #include "extensions/common/manifest_handlers/icons_handler.h"
  41 #include "ui/gfx/image/image.h"
  42 #include "ui/gfx/rect.h"
  43
  44 using base::UserMetricsAction;
  45 using content::RenderViewHost;
  46
  47 namespace panel_internal {
  48
  49 class PanelExtensionWindowController : public extensions::WindowController {
  50  public:
  51   PanelExtensionWindowController(Panel* panel, Profile* profile);
  52   virtual ~PanelExtensionWindowController();
  53
  54   // Overridden from extensions::WindowController.
  55   virtual int GetWindowId() const OVERRIDE;
  56   virtual std::string GetWindowTypeText() const OVERRIDE;
  57   virtual base::DictionaryValue* CreateWindowValueWithTabs(
  58       const extensions::Extension* extension) const OVERRIDE;
  59   virtual base::DictionaryValue* CreateTabValue(
  60       const extensions::Extension* extension, int tab_index) const OVERRIDE;
  61   virtual bool CanClose(Reason* reason) const OVERRIDE;
  62   virtual void SetFullscreenMode(bool is_fullscreen,
  63                                  const GURL& extension_url) const OVERRIDE;
  64   virtual bool IsVisibleToExtension(
  65       const extensions::Extension* extension) const OVERRIDE;
  66
  67  private:
  68   Panel* panel_;  // Weak pointer. Owns us.
  69   DISALLOW_COPY_AND_ASSIGN(PanelExtensionWindowController);
  70 };
  71
  72 PanelExtensionWindowController::PanelExtensionWindowController(
  73     Panel* panel, Profile* profile)
  74     : extensions::WindowController(panel, profile),
  75       panel_(panel) {
  76   extensions::WindowControllerList::GetInstance()->AddExtensionWindow(this);
  77 }
  78
  79 PanelExtensionWindowController::~PanelExtensionWindowController() {
  80   extensions::WindowControllerList::GetInstance()->RemoveExtensionWindow(this);
  81 }
  82
  83 int PanelExtensionWindowController::GetWindowId() const {
  84   return static_cast<int>(panel_->session_id().id());
  85 }
  86
  87 std::string PanelExtensionWindowController::GetWindowTypeText() const {
  88   return extensions::tabs_constants::kWindowTypeValuePanel;
  89 }
  90
  91 base::DictionaryValue*
  92 PanelExtensionWindowController::CreateWindowValueWithTabs(
  93     const extensions::Extension* extension) const {
  94   base::DictionaryValue* result = CreateWindowValue();
  95
  96   DCHECK(IsVisibleToExtension(extension));
  97   base::DictionaryValue* tab_value = CreateTabValue(extension, 0);
  98   if (tab_value) {
  99     base::ListValue* tab_list = new base::ListValue();
 100     tab_list->Append(tab_value);
 101     result->Set(extensions::tabs_constants::kTabsKey, tab_list);
 102   }
 103   return result;
 104 }
 105
 106 base::DictionaryValue* PanelExtensionWindowController::CreateTabValue(
 107     const extensions::Extension* extension, int tab_index) const {
 108   if (tab_index > 0)
 109     return NULL;
 110
 111   content::WebContents* web_contents = panel_->GetWebContents();
 112   if (!web_contents)
 113     return NULL;
 114
 115   DCHECK(IsVisibleToExtension(extension));
 116   base::DictionaryValue* tab_value = new base::DictionaryValue();
 117   tab_value->SetInteger(extensions::tabs_constants::kIdKey,
 118                         SessionID::IdForTab(web_contents));
 119   tab_value->SetInteger(extensions::tabs_constants::kIndexKey, 0);
 120   tab_value->SetInteger(extensions::tabs_constants::kWindowIdKey,
 121                         SessionID::IdForWindowContainingTab(web_contents));
 122   tab_value->SetString(
 123       extensions::tabs_constants::kUrlKey, web_contents->GetURL().spec());
 124   tab_value->SetString(extensions::tabs_constants::kStatusKey,
 125                        extensions::ExtensionTabUtil::GetTabStatusText(
 126                            web_contents->IsLoading()));
 127   tab_value->SetBoolean(
 128       extensions::tabs_constants::kActiveKey, panel_->IsActive());
 129   tab_value->SetBoolean(extensions::tabs_constants::kSelectedKey, true);
 130   tab_value->SetBoolean(extensions::tabs_constants::kHighlightedKey, true);
 131   tab_value->SetBoolean(extensions::tabs_constants::kPinnedKey, false);
 132   tab_value->SetString(
 133       extensions::tabs_constants::kTitleKey, web_contents->GetTitle());
 134   tab_value->SetBoolean(
 135       extensions::tabs_constants::kIncognitoKey,
 136       web_contents->GetBrowserContext()->IsOffTheRecord());
 137   return tab_value;
 138 }
 139
 140 bool PanelExtensionWindowController::CanClose(Reason* reason) const {
 141   return true;
 142 }
 143
 144 void PanelExtensionWindowController::SetFullscreenMode(
 145     bool is_fullscreen, const GURL& extension_url) const {
 146   // Do nothing. Panels cannot be fullscreen.
 147 }
 148
 149 bool PanelExtensionWindowController::IsVisibleToExtension(
 150     const extensions::Extension* extension) const {
 151   return extension->id() == panel_->extension_id();
 152 }
 153
 154 }  // namespace panel_internal
 155
 156 Panel::~Panel() {
 157   DCHECK(!collection_);
 158 #if !defined(USE_AURA)
 159   // Invoked by native panel destructor. Do not access native_panel_ here.
 160   chrome::DecrementKeepAliveCount();  // Remove shutdown prevention.
 161 #endif
 162 }
 163
 164 PanelManager* Panel::manager() const {
 165   return PanelManager::GetInstance();
 166 }
 167
 168 const std::string Panel::extension_id() const {
 169   return web_app::GetExtensionIdFromApplicationName(app_name_);
 170 }
 171
 172 CommandUpdater* Panel::command_updater() {
 173   return &command_updater_;
 174 }
 175
 176 Profile* Panel::profile() const {
 177   return profile_;
 178 }
 179
 180 const extensions::Extension* Panel::GetExtension() const {
 181   ExtensionService* extension_service =
 182       extensions::ExtensionSystem::Get(profile())->extension_service();
 183   if (!extension_service || !extension_service->is_ready())
 184     return NULL;
 185   return extension_service->GetExtensionById(extension_id(), false);
 186 }
 187
 188 content::WebContents* Panel::GetWebContents() const {
 189   return panel_host_.get() ? panel_host_->web_contents() : NULL;
 190 }
 191
 192 void Panel::SetExpansionState(ExpansionState new_state) {
 193   if (expansion_state_ == new_state)
 194     return;
 195   native_panel_->PanelExpansionStateChanging(expansion_state_, new_state);
 196   expansion_state_ = new_state;
 197
 198   manager()->OnPanelExpansionStateChanged(this);
 199
 200   DCHECK(initialized_ && collection_ != NULL);
 201   native_panel_->PreventActivationByOS(collection_->IsPanelMinimized(this));
 202   UpdateMinimizeRestoreButtonVisibility();
 203
 204   content::NotificationService::current()->Notify(
 205       chrome::NOTIFICATION_PANEL_CHANGED_EXPANSION_STATE,
 206       content::Source<Panel>(this),
 207       content::NotificationService::NoDetails());
 208 }
 209
 210 bool Panel::IsDrawingAttention() const {
 211   return native_panel_->IsDrawingAttention();
 212 }
 213
 214 void Panel::FullScreenModeChanged(bool is_full_screen) {
 215   native_panel_->FullScreenModeChanged(is_full_screen);
 216 }
 217
 218 int Panel::TitleOnlyHeight() const {
 219   return native_panel_->TitleOnlyHeight();
 220 }
 221
 222 bool Panel::CanShowMinimizeButton() const {
 223   return collection_ && collection_->CanShowMinimizeButton(this);
 224 }
 225
 226 bool Panel::CanShowRestoreButton() const {
 227   return collection_ && collection_->CanShowRestoreButton(this);
 228 }
 229
 230 bool Panel::IsActive() const {
 231   return native_panel_->IsPanelActive();
 232 }
 233
 234 bool Panel::IsMaximized() const {
 235   // Size of panels is managed by PanelManager, they are never 'zoomed'.
 236   return false;
 237 }
 238
 239 bool Panel::IsMinimized() const {
 240   return !collection_ || collection_->IsPanelMinimized(this);
 241 }
 242
 243 bool Panel::IsFullscreen() const {
 244   return false;
 245 }
 246
 247 gfx::NativeWindow Panel::GetNativeWindow() {
 248   return native_panel_->GetNativePanelWindow();
 249 }
 250
 251 gfx::Rect Panel::GetRestoredBounds() const {
 252   gfx::Rect bounds = native_panel_->GetPanelBounds();
 253   bounds.set_y(bounds.bottom() - full_size_.height());
 254   bounds.set_x(bounds.right() - full_size_.width());
 255   bounds.set_size(full_size_);
 256   return bounds;
 257 }
 258
 259 ui::WindowShowState Panel::GetRestoredState() const {
 260   return ui::SHOW_STATE_NORMAL;
 261 }
 262
 263 gfx::Rect Panel::GetBounds() const {
 264   return native_panel_->GetPanelBounds();
 265 }
 266
 267 void Panel::Show() {
 268   if (manager()->display_settings_provider()->is_full_screen() || !collection_)
 269     return;
 270
 271   native_panel_->ShowPanel();
 272 }
 273
 274 void Panel::Hide() {
 275   // Not implemented.
 276 }
 277
 278 void Panel::ShowInactive() {
 279   if (manager()->display_settings_provider()->is_full_screen() || !collection_)
 280     return;
 281
 282   native_panel_->ShowPanelInactive();
 283 }
 284
 285 // Close() may be called multiple times if the panel window is not ready to
 286 // close on the first attempt.
 287 void Panel::Close() {
 288   native_panel_->ClosePanel();
 289 }
 290
 291 void Panel::Activate() {
 292   if (!collection_)
 293     return;
 294
 295   collection_->ActivatePanel(this);
 296   native_panel_->ActivatePanel();
 297 }
 298
 299 void Panel::Deactivate() {
 300   native_panel_->DeactivatePanel();
 301 }
 302
 303 void Panel::Maximize() {
 304   Restore();
 305 }
 306
 307 void Panel::Minimize() {
 308   if (collection_)
 309     collection_->MinimizePanel(this);
 310 }
 311
 312 bool Panel::IsMinimizedBySystem() const {
 313   return native_panel_->IsPanelMinimizedBySystem();
 314 }
 315
 316 bool Panel::IsShownOnActiveDesktop() const {
 317   return native_panel_->IsPanelShownOnActiveDesktop();
 318 }
 319
 320 void Panel::ShowShadow(bool show) {
 321   native_panel_->ShowShadow(show);
 322 }
 323
 324 void Panel::Restore() {
 325   if (collection_)
 326     collection_->RestorePanel(this);
 327 }
 328
 329 void Panel::SetBounds(const gfx::Rect& bounds) {
 330   // Ignore bounds position as the panel manager controls all positioning.
 331   if (!collection_)
 332     return;
 333   collection_->ResizePanelWindow(this, bounds.size());
 334   SetAutoResizable(false);
 335 }
 336
 337 void Panel::FlashFrame(bool draw_attention) {
 338   if (IsDrawingAttention() == draw_attention || !collection_)
 339     return;
 340
 341   // Don't draw attention for an active panel.
 342   if (draw_attention && IsActive())
 343     return;
 344
 345   // Invoking native panel to draw attention must be done before informing the
 346   // panel collection because it needs to check internal state of the panel to
 347   // determine if the panel has been drawing attention.
 348   native_panel_->DrawAttention(draw_attention);
 349   collection_->OnPanelAttentionStateChanged(this);
 350 }
 351
 352 bool Panel::IsAlwaysOnTop() const {
 353   return native_panel_->IsPanelAlwaysOnTop();
 354 }
 355
 356 void Panel::SetAlwaysOnTop(bool on_top) {
 357   native_panel_->SetPanelAlwaysOnTop(on_top);
 358 }
 359
 360 void Panel::ExecuteCommandWithDisposition(int id,
 361                                           WindowOpenDisposition disposition) {
 362   DCHECK(command_updater_.IsCommandEnabled(id)) << "Invalid/disabled command "
 363                                                 << id;
 364
 365   if (!GetWebContents())
 366     return;
 367
 368   switch (id) {
 369     // Navigation
 370     case IDC_RELOAD:
 371       panel_host_->Reload();
 372       break;
 373     case IDC_RELOAD_IGNORING_CACHE:
 374       panel_host_->ReloadIgnoringCache();
 375       break;
 376     case IDC_STOP:
 377       panel_host_->StopLoading();
 378       break;
 379
 380     // Window management
 381     case IDC_CLOSE_WINDOW:
 382       content::RecordAction(UserMetricsAction("CloseWindow"));
 383       Close();
 384       break;
 385     case IDC_EXIT:
 386       content::RecordAction(UserMetricsAction("Exit"));
 387       chrome::AttemptUserExit();
 388       break;
 389
 390     // Clipboard
 391     case IDC_COPY:
 392       content::RecordAction(UserMetricsAction("Copy"));
 393       native_panel_->PanelCopy();
 394       break;
 395     case IDC_CUT:
 396       content::RecordAction(UserMetricsAction("Cut"));
 397       native_panel_->PanelCut();
 398       break;
 399     case IDC_PASTE:
 400       content::RecordAction(UserMetricsAction("Paste"));
 401       native_panel_->PanelPaste();
 402       break;
 403
 404     // Zoom
 405     case IDC_ZOOM_PLUS:
 406       panel_host_->Zoom(content::PAGE_ZOOM_IN);
 407       break;
 408     case IDC_ZOOM_NORMAL:
 409       panel_host_->Zoom(content::PAGE_ZOOM_RESET);
 410       break;
 411     case IDC_ZOOM_MINUS:
 412       panel_host_->Zoom(content::PAGE_ZOOM_OUT);
 413       break;
 414
 415     // DevTools
 416     case IDC_DEV_TOOLS:
 417       content::RecordAction(UserMetricsAction("DevTools_ToggleWindow"));
 418       DevToolsWindow::OpenDevToolsWindow(
 419           GetWebContents()->GetRenderViewHost(),
 420           DevToolsToggleAction::Show());
 421       break;
 422     case IDC_DEV_TOOLS_CONSOLE:
 423       content::RecordAction(UserMetricsAction("DevTools_ToggleConsole"));
 424       DevToolsWindow::OpenDevToolsWindow(
 425           GetWebContents()->GetRenderViewHost(),
 426           DevToolsToggleAction::ShowConsole());
 427       break;
 428
 429     default:
 430       LOG(WARNING) << "Received unimplemented command: " << id;
 431       break;
 432   }
 433 }
 434
 435 void Panel::Observe(int type,
 436                     const content::NotificationSource& source,
 437                     const content::NotificationDetails& details) {
 438   switch (type) {
 439     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED:
 440       ConfigureAutoResize(content::Source<content::WebContents>(source).ptr());
 441       break;
 442     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED:
 443       if (content::Details<extensions::UnloadedExtensionInfo>(
 444               details)->extension->id() == extension_id())
 445         Close();
 446       break;
 447     case chrome::NOTIFICATION_APP_TERMINATING:
 448       Close();
 449       break;
 450     default:
 451       NOTREACHED() << "Received unexpected notification " << type;
 452   }
 453 }
 454
 455 void Panel::OnTitlebarClicked(panel::ClickModifier modifier) {
 456   if (collection_)
 457     collection_->OnPanelTitlebarClicked(this, modifier);
 458
 459   // Normally the system activates a window when the titlebar is clicked.
 460   // However, we prevent system activation of minimized panels, thus the
 461   // activation may not have occurred. Also, some OSes (Windows) will
 462   // activate a minimized panel on mouse-down regardless of our attempts to
 463   // prevent system activation. Attention state is not cleared in that case.
 464   // See Panel::OnActiveStateChanged().
 465   // Therefore, we ensure activation and clearing of attention state if the
 466   // panel has been expanded. If the panel is in a stack, the titlebar click
 467   // might minimize the panel and we do not want to activate it to make it
 468   // expand again.
 469   // These are no-ops if no changes are needed.
 470   if (IsMinimized())
 471     return;
 472   Activate();
 473   FlashFrame(false);
 474 }
 475
 476 void Panel::OnMinimizeButtonClicked(panel::ClickModifier modifier) {
 477   if (collection_)
 478     collection_->OnMinimizeButtonClicked(this, modifier);
 479 }
 480
 481 void Panel::OnRestoreButtonClicked(panel::ClickModifier modifier) {
 482   // Clicking the restore button has the same behavior as clicking the titlebar.
 483   OnTitlebarClicked(modifier);
 484 }
 485
 486 void Panel::OnWindowSizeAvailable() {
 487   ConfigureAutoResize(GetWebContents());
 488 }
 489
 490 void Panel::OnNativePanelClosed() {
 491   // Ensure previously enqueued OnImageLoaded callbacks are ignored.
 492   image_loader_ptr_factory_.InvalidateWeakPtrs();
 493   registrar_.RemoveAll();
 494   manager()->OnPanelClosed(this);
 495   DCHECK(!collection_);
 496 }
 497
 498 StackedPanelCollection* Panel::stack() const {
 499   return collection_ && collection_->type() == PanelCollection::STACKED ?
 500       static_cast<StackedPanelCollection*>(collection_) : NULL;
 501 }
 502
 503 panel::Resizability Panel::CanResizeByMouse() const {
 504   if (!collection_)
 505     return panel::NOT_RESIZABLE;
 506
 507   return collection_->GetPanelResizability(this);
 508 }
 509
 510 void Panel::Initialize(const GURL& url,
 511                        const gfx::Rect& bounds,
 512                        bool always_on_top) {
 513   DCHECK(!initialized_);
 514   DCHECK(!collection_);  // Cannot be added to a collection until fully created.
 515   DCHECK_EQ(EXPANDED, expansion_state_);
 516   DCHECK(!bounds.IsEmpty());
 517   initialized_ = true;
 518   full_size_ = bounds.size();
 519   native_panel_ = CreateNativePanel(this, bounds, always_on_top);
 520
 521   extension_window_controller_.reset(
 522       new panel_internal::PanelExtensionWindowController(this, profile_));
 523
 524   InitCommandState();
 525
 526   // Set up hosting for web contents.
 527   panel_host_.reset(new PanelHost(this, profile_));
 528   panel_host_->Init(url);
 529   content::WebContents* web_contents = GetWebContents();
 530   // The contents might be NULL for most of our tests.
 531   if (web_contents)
 532     native_panel_->AttachWebContents(web_contents);
 533
 534   // Close when the extension is unloaded or the browser is exiting.
 535   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 536                  content::Source<Profile>(profile_));
 537   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
 538                  content::NotificationService::AllSources());
 539   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
 540                  content::Source<ThemeService>(
 541                     ThemeServiceFactory::GetForProfile(profile_)));
 542
 543 #if !defined(USE_AURA)
 544   // Keep alive for AURA has been moved to panel_view.
 545   // Prevent the browser process from shutting down while this window is open.
 546   chrome::IncrementKeepAliveCount();
 547 #endif
 548
 549   UpdateAppIcon();
 550 }
 551
 552 void Panel::SetPanelBounds(const gfx::Rect& bounds) {
 553   if (bounds != native_panel_->GetPanelBounds())
 554     native_panel_->SetPanelBounds(bounds);
 555 }
 556
 557 void Panel::SetPanelBoundsInstantly(const gfx::Rect& bounds) {
 558   native_panel_->SetPanelBoundsInstantly(bounds);
 559 }
 560
 561 void Panel::LimitSizeToWorkArea(const gfx::Rect& work_area) {
 562   int max_width = manager()->GetMaxPanelWidth(work_area);
 563   int max_height = manager()->GetMaxPanelHeight(work_area);
 564
 565   // If the custom max size is used, ensure that it does not exceed the display
 566   // area.
 567   if (max_size_policy_ == CUSTOM_MAX_SIZE) {
 568     int current_max_width = max_size_.width();
 569     if (current_max_width > max_width)
 570       max_width = std::min(current_max_width, work_area.width());
 571     int current_max_height = max_size_.height();
 572     if (current_max_height > max_height)
 573       max_height = std::min(current_max_height, work_area.height());
 574   }
 575
 576   SetSizeRange(min_size_, gfx::Size(max_width, max_height));
 577
 578   // Ensure that full size does not exceed max size.
 579   full_size_ = ClampSize(full_size_);
 580 }
 581
 582 void Panel::SetAutoResizable(bool resizable) {
 583   if (auto_resizable_ == resizable)
 584     return;
 585
 586   auto_resizable_ = resizable;
 587   content::WebContents* web_contents = GetWebContents();
 588   if (auto_resizable_) {
 589     if (web_contents)
 590       EnableWebContentsAutoResize(web_contents);
 591   } else {
 592     if (web_contents) {
 593       registrar_.Remove(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
 594                         content::Source<content::WebContents>(web_contents));
 595
 596       // NULL might be returned if the tab has not been added.
 597       RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
 598       if (render_view_host)
 599         render_view_host->DisableAutoResize(full_size_);
 600     }
 601   }
 602 }
 603
 604 void Panel::EnableWebContentsAutoResize(content::WebContents* web_contents) {
 605   DCHECK(web_contents);
 606   ConfigureAutoResize(web_contents);
 607
 608   // We also need to know when the render view host changes in order
 609   // to turn on auto-resize notifications in the new render view host.
 610   if (!registrar_.IsRegistered(
 611           this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
 612           content::Source<content::WebContents>(web_contents))) {
 613     registrar_.Add(
 614         this,
 615         content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
 616         content::Source<content::WebContents>(web_contents));
 617   }
 618 }
 619
 620 void Panel::OnContentsAutoResized(const gfx::Size& new_content_size) {
 621   DCHECK(auto_resizable_);
 622   if (!collection_)
 623     return;
 624
 625   gfx::Size new_window_size =
 626       native_panel_->WindowSizeFromContentSize(new_content_size);
 627
 628   // Ignore content auto resizes until window frame size is known.
 629   // This reduces extra resizes when panel is first shown.
 630   // After window frame size is known, it will trigger another content
 631   // auto resize.
 632   if (new_content_size == new_window_size)
 633     return;
 634
 635   collection_->ResizePanelWindow(this, new_window_size);
 636 }
 637
 638 void Panel::OnWindowResizedByMouse(const gfx::Rect& new_bounds) {
 639   if (collection_)
 640     collection_->OnPanelResizedByMouse(this, new_bounds);
 641 }
 642
 643 void Panel::SetSizeRange(const gfx::Size& min_size, const gfx::Size& max_size) {
 644   if (min_size == min_size_ && max_size == max_size_)
 645     return;
 646
 647   DCHECK(min_size.width() <= max_size.width());
 648   DCHECK(min_size.height() <= max_size.height());
 649   min_size_ = min_size;
 650   max_size_ = max_size;
 651
 652   ConfigureAutoResize(GetWebContents());
 653 }
 654
 655 void Panel::IncreaseMaxSize(const gfx::Size& desired_panel_size) {
 656   gfx::Size new_max_size = max_size_;
 657   if (new_max_size.width() < desired_panel_size.width())
 658     new_max_size.set_width(desired_panel_size.width());
 659   if (new_max_size.height() < desired_panel_size.height())
 660     new_max_size.set_height(desired_panel_size.height());
 661
 662   SetSizeRange(min_size_, new_max_size);
 663 }
 664
 665 void Panel::HandleKeyboardEvent(const content::NativeWebKeyboardEvent& event) {
 666   native_panel_->HandlePanelKeyboardEvent(event);
 667 }
 668
 669 void Panel::SetPreviewMode(bool in_preview) {
 670   DCHECK_NE(in_preview_mode_, in_preview);
 671   in_preview_mode_ = in_preview;
 672 }
 673
 674 void Panel::UpdateMinimizeRestoreButtonVisibility() {
 675   native_panel_->UpdatePanelMinimizeRestoreButtonVisibility();
 676 }
 677
 678 gfx::Size Panel::ClampSize(const gfx::Size& size) const {
 679   // The panel width:
 680   // * cannot grow or shrink to go beyond [min_width, max_width]
 681   int new_width = size.width();
 682   if (new_width > max_size_.width())
 683     new_width = max_size_.width();
 684   if (new_width < min_size_.width())
 685     new_width = min_size_.width();
 686
 687   // The panel height:
 688   // * cannot grow or shrink to go beyond [min_height, max_height]
 689   int new_height = size.height();
 690   if (new_height > max_size_.height())
 691     new_height = max_size_.height();
 692   if (new_height < min_size_.height())
 693     new_height = min_size_.height();
 694
 695   return gfx::Size(new_width, new_height);
 696 }
 697
 698 void Panel::OnActiveStateChanged(bool active) {
 699   // Clear attention state when an expanded panel becomes active.
 700   // On some systems (e.g. Win), mouse-down activates a panel regardless of
 701   // its expansion state. However, we don't want to clear draw attention if
 702   // contents are not visible. In that scenario, if the mouse-down results
 703   // in a mouse-click, draw attention will be cleared then.
 704   // See Panel::OnTitlebarClicked().
 705   if (active && IsDrawingAttention() && !IsMinimized())
 706     FlashFrame(false);
 707
 708   if (collection_)
 709     collection_->OnPanelActiveStateChanged(this);
 710
 711   // Send extension event about window changing active state.
 712   extensions::TabsWindowsAPI* tabs_windows_api =
 713       extensions::TabsWindowsAPI::Get(profile());
 714   if (tabs_windows_api) {
 715     tabs_windows_api->windows_event_router()->OnActiveWindowChanged(
 716         active ? extension_window_controller_.get() : NULL);
 717   }
 718
 719   content::NotificationService::current()->Notify(
 720       chrome::NOTIFICATION_PANEL_CHANGED_ACTIVE_STATUS,
 721       content::Source<Panel>(this),
 722       content::NotificationService::NoDetails());
 723 }
 724
 725 void Panel::OnPanelStartUserResizing() {
 726   SetAutoResizable(false);
 727   SetPreviewMode(true);
 728   max_size_policy_ = CUSTOM_MAX_SIZE;
 729 }
 730
 731 void Panel::OnPanelEndUserResizing() {
 732   SetPreviewMode(false);
 733 }
 734
 735 bool Panel::ShouldCloseWindow() {
 736   return true;
 737 }
 738
 739 void Panel::OnWindowClosing() {
 740   if (GetWebContents()) {
 741     native_panel_->DetachWebContents(GetWebContents());
 742     panel_host_->DestroyWebContents();
 743   }
 744 }
 745
 746 bool Panel::ExecuteCommandIfEnabled(int id) {
 747   if (command_updater()->SupportsCommand(id) &&
 748       command_updater()->IsCommandEnabled(id)) {
 749     ExecuteCommandWithDisposition(id, CURRENT_TAB);
 750     return true;
 751   }
 752   return false;
 753 }
 754
 755 base::string16 Panel::GetWindowTitle() const {
 756   content::WebContents* contents = GetWebContents();
 757   base::string16 title;
 758
 759   // |contents| can be NULL during the window's creation.
 760   if (contents) {
 761     title = contents->GetTitle();
 762     FormatTitleForDisplay(&title);
 763   }
 764
 765   if (title.empty())
 766     title = base::UTF8ToUTF16(app_name());
 767
 768   return title;
 769 }
 770
 771 gfx::Image Panel::GetCurrentPageIcon() const {
 772   return panel_host_->GetPageIcon();
 773 }
 774
 775 void Panel::UpdateTitleBar() {
 776   native_panel_->UpdatePanelTitleBar();
 777 }
 778
 779 void Panel::LoadingStateChanged(bool is_loading) {
 780   command_updater_.UpdateCommandEnabled(IDC_STOP, is_loading);
 781   native_panel_->UpdatePanelLoadingAnimations(is_loading);
 782   UpdateTitleBar();
 783 }
 784
 785 void Panel::WebContentsFocused(content::WebContents* contents) {
 786   native_panel_->PanelWebContentsFocused(contents);
 787 }
 788
 789 void Panel::MoveByInstantly(const gfx::Vector2d& delta_origin) {
 790   gfx::Rect bounds = GetBounds();
 791   bounds.Offset(delta_origin);
 792   SetPanelBoundsInstantly(bounds);
 793 }
 794
 795 void Panel::SetWindowCornerStyle(panel::CornerStyle corner_style) {
 796   native_panel_->SetWindowCornerStyle(corner_style);
 797 }
 798
 799 void Panel::MinimizeBySystem() {
 800   native_panel_->MinimizePanelBySystem();
 801 }
 802
 803 Panel::Panel(Profile* profile, const std::string& app_name,
 804              const gfx::Size& min_size, const gfx::Size& max_size)
 805     : app_name_(app_name),
 806       profile_(profile),
 807       collection_(NULL),
 808       initialized_(false),
 809       min_size_(min_size),
 810       max_size_(max_size),
 811       max_size_policy_(DEFAULT_MAX_SIZE),
 812       auto_resizable_(false),
 813       in_preview_mode_(false),
 814       native_panel_(NULL),
 815       attention_mode_(USE_PANEL_ATTENTION),
 816       expansion_state_(EXPANDED),
 817       command_updater_(this),
 818       image_loader_ptr_factory_(this) {
 819 }
 820
 821 void Panel::OnImageLoaded(const gfx::Image& image) {
 822   if (!image.IsEmpty()) {
 823     app_icon_ = image;
 824     native_panel_->UpdatePanelTitleBar();
 825   }
 826
 827   content::NotificationService::current()->Notify(
 828       chrome::NOTIFICATION_PANEL_APP_ICON_LOADED,
 829       content::Source<Panel>(this),
 830       content::NotificationService::NoDetails());
 831 }
 832
 833 void Panel::InitCommandState() {
 834   // All supported commands whose state isn't set automagically some other way
 835   // (like Stop during a page load) must have their state initialized here,
 836   // otherwise they will be forever disabled.
 837
 838   // Navigation commands
 839   command_updater_.UpdateCommandEnabled(IDC_RELOAD, true);
 840   command_updater_.UpdateCommandEnabled(IDC_RELOAD_IGNORING_CACHE, true);
 841
 842   // Window management commands
 843   command_updater_.UpdateCommandEnabled(IDC_CLOSE_WINDOW, true);
 844   command_updater_.UpdateCommandEnabled(IDC_EXIT, true);
 845
 846   // Zoom
 847   command_updater_.UpdateCommandEnabled(IDC_ZOOM_MENU, true);
 848   command_updater_.UpdateCommandEnabled(IDC_ZOOM_PLUS, true);
 849   command_updater_.UpdateCommandEnabled(IDC_ZOOM_NORMAL, true);
 850   command_updater_.UpdateCommandEnabled(IDC_ZOOM_MINUS, true);
 851
 852   // Clipboard
 853   command_updater_.UpdateCommandEnabled(IDC_COPY, true);
 854   command_updater_.UpdateCommandEnabled(IDC_CUT, true);
 855   command_updater_.UpdateCommandEnabled(IDC_PASTE, true);
 856
 857   // DevTools
 858   command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS, true);
 859   command_updater_.UpdateCommandEnabled(IDC_DEV_TOOLS_CONSOLE, true);
 860 }
 861
 862 void Panel::ConfigureAutoResize(content::WebContents* web_contents) {
 863   if (!auto_resizable_ || !web_contents)
 864     return;
 865
 866   // NULL might be returned if the tab has not been added.
 867   RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
 868   if (!render_view_host)
 869     return;
 870
 871   render_view_host->EnableAutoResize(
 872       min_size_,
 873       native_panel_->ContentSizeFromWindowSize(max_size_));
 874 }
 875
 876 void Panel::UpdateAppIcon() {
 877   const extensions::Extension* extension = GetExtension();
 878   if (!extension)
 879     return;
 880
 881   extensions::ImageLoader* loader = extensions::ImageLoader::Get(profile());
 882   loader->LoadImageAsync(
 883       extension,
 884       extensions::IconsInfo::GetIconResource(
 885           extension,
 886           extension_misc::EXTENSION_ICON_SMALL,
 887           ExtensionIconSet::MATCH_BIGGER),
 888       gfx::Size(extension_misc::EXTENSION_ICON_SMALL,
 889                 extension_misc::EXTENSION_ICON_SMALL),
 890       base::Bind(&Panel::OnImageLoaded,
 891                  image_loader_ptr_factory_.GetWeakPtr()));
 892 }
 893
 894 // static
 895 void Panel::FormatTitleForDisplay(base::string16* title) {
 896   size_t current_index = 0;
 897   size_t match_index;
 898   while ((match_index = title->find(L'\n', current_index)) !=
 899          base::string16::npos) {
 900     title->replace(match_index, 1, base::string16());
 901     current_index = match_index;
 902   }
 903 }