WebUI TaskManager: Add method to set minimum window size on HTMLDialog.

chrome/browser/ui/webui/task_manager_dialog.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/task_manager_dialog.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/utf_string_conversions.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "grit/google_chrome_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/views/widget/widget.h"
 #endif
 
+namespace {
+const int kMinimumTaskManagerWidth = 640;

[James Hawkins, 2012/03/15 16:34:36]

nit: Either comment or add Px to the name that this is in pixels.

[yoshiki, 2012/03/16 05:55:10]

Done.

+const int kMinimumTaskManagerHeight = 480;
+}  // namespace
+
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 class TaskManagerDialogImpl : public HtmlDialogUIDelegate {
  public:
   TaskManagerDialogImpl();
 
   static void Show(bool is_background_page_mode);
   static TaskManagerDialogImpl* GetInstance();
 
  protected:
   friend struct DefaultSingletonTraits<TaskManagerDialogImpl>;
   virtual ~TaskManagerDialogImpl();
 
   void OnCloseDialog();
 
   // Overridden from HtmlDialogUIDelegate:
   virtual ui::ModalType GetDialogModalType() const OVERRIDE {
     return ui::MODAL_TYPE_NONE;
   }
   virtual string16 GetDialogTitle() const OVERRIDE {
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_TITLE);
   }
+  virtual std::string GetDialogName() const OVERRIDE {
+    return prefs::kTaskManagerWindowPlacement;
+  }
   virtual GURL GetDialogContentURL() const OVERRIDE {
     std::string url_string(chrome::kChromeUITaskManagerURL);
     url_string += "?";
     if (browser_defaults::kShowCancelButtonInTaskManager)
       url_string += "showclose=1&";
     if (browser_defaults::kShowHtmlTitleBarInTaskManager)
       url_string += "showtitle=1&";
     if (is_background_page_mode_)
       url_string += "background=1";
     return GURL(url_string);
   }
   virtual void GetWebUIMessageHandlers(
       std::vector<WebUIMessageHandler*>* handlers) const OVERRIDE {
   }
   virtual void GetDialogSize(gfx::Size* size) const OVERRIDE {
+#if !defined(TOOLKIT_VIEWS)
     // If dialog's bounds are previously saved, use them.
     if (g_browser_process->local_state()) {
       const DictionaryValue* placement_pref =
           g_browser_process->local_state()->GetDictionary(
           prefs::kTaskManagerWindowPlacement);
       int width, height;
       if (placement_pref &&
           placement_pref->GetInteger("width", &width) &&
           placement_pref->GetInteger("height", &height)) {
         size->SetSize(std::max(1, width), std::max(1, height));
         return;
       }
     }
 
     // Otherwise set default size.
-    size->SetSize(640, 480);
+    size->SetSize(kMimimumTaskManagerWidth, kMinimumTaskManagerHeight);
+#endif
+  }
+  virtual void GetMinimumDialogSize(gfx::Size* size) const OVERRIDE {
+    size->SetSize(kMinimumTaskManagerWidth, kMinimumTaskManagerHeight);
   }
   virtual std::string GetDialogArgs() const OVERRIDE {
     return std::string();
   }
   virtual void OnDialogClosed(const std::string& json_retval) OVERRIDE {
     OnCloseDialog();
   }
   virtual void OnCloseContents(WebContents* source, bool* out_close_dialog)
       OVERRIDE {
     *out_close_dialog = true;
   }
   virtual bool ShouldShowDialogTitle() const OVERRIDE {
     return false;
   }
   virtual bool HandleContextMenu(
       const content::ContextMenuParams& params) OVERRIDE {
     return true;
   }
+#if !defined(TOOLKIT_VIEWS)
   virtual void StoreDialogSize(const gfx::Size& dialog_size) OVERRIDE {
    // Store the dialog's bounds so that it can be restored with the same bounds
    // the next time it's opened.
    if (g_browser_process->local_state()) {
      DictionaryPrefUpdate update(g_browser_process->local_state(),
                                  prefs::kTaskManagerWindowPlacement);
      DictionaryValue* placement_pref = update.Get();
      placement_pref->SetInteger("width", dialog_size.width());
      placement_pref->SetInteger("height", dialog_size.height());
    }
  }
+#endif
 
  private:
   void ShowDialog(bool is_background_page_mode);
   void OpenHtmlDialog();
 
   int show_count_;
 
   gfx::NativeWindow window_;
   bool is_background_page_mode_;
 
@@ skipping 70 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TaskManagerDialogImpl::Show, true));
 }
 
 // static
 bool TaskManagerDialog::UseWebUITaskManager() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kWebUITaskManager);
 }