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