Add new methods to create constrained windows for print preview and release the internal TabConte...

chrome/browser/ui/webui/constrained_html_ui_browsertest.cc

 // Copyright (c) 2011 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/test/ui/ui_test.h"
 
-#include "base/file_path.h"
-#include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/webui/constrained_html_ui.h"
 #include "chrome/browser/ui/webui/html_dialog_ui.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
-#include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/tab_contents/tab_contents.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::Eq;
+#include "content/browser/tab_contents/tab_contents_observer.h"
 
 namespace {
 
+class ConstrainedHtmlDialogBrowserTestHandler : public WebUIMessageHandler {
+ public:
+  ConstrainedHtmlDialogBrowserTestHandler() {}
+  virtual ~ConstrainedHtmlDialogBrowserTestHandler() {}
+
+  ConstrainedHtmlUI* constrained_ui() {
+    return static_cast<ConstrainedHtmlUI*>(web_ui());
+  }
+ private:
+  virtual void RegisterMessages() {}
+};
+
 class TestHtmlDialogUIDelegate : public HtmlDialogUIDelegate {
  public:
-  TestHtmlDialogUIDelegate() {}
+  TestHtmlDialogUIDelegate() {
+    test_handler_.reset(new ConstrainedHtmlDialogBrowserTestHandler);
+  }
   virtual ~TestHtmlDialogUIDelegate() {}
 
   // HTMLDialogUIDelegate implementation:
   virtual bool IsDialogModal() const OVERRIDE {
     return true;
   }
   virtual string16 GetDialogTitle() const OVERRIDE {
     return UTF8ToUTF16("Test");
   }
   virtual GURL GetDialogContentURL() const OVERRIDE {
     return GURL(chrome::kChromeUIConstrainedHTMLTestURL);
   }
   virtual void GetWebUIMessageHandlers(
-      std::vector<WebUIMessageHandler*>* handlers) const OVERRIDE {}
+      std::vector<WebUIMessageHandler*>* handlers) const OVERRIDE {
+    handlers->push_back(test_handler_.get());
+  }
   virtual void GetDialogSize(gfx::Size* size) const OVERRIDE {
     size->set_width(400);
     size->set_height(400);
   }
   virtual std::string GetDialogArgs() const OVERRIDE {
     return std::string();
   }
   virtual void OnDialogClosed(const std::string& json_retval) OVERRIDE { }
   virtual void OnCloseContents(TabContents* source, bool* out_close_dialog)
       OVERRIDE {
     if (out_close_dialog)
       *out_close_dialog = true;
   }
   virtual bool ShouldShowDialogTitle() const OVERRIDE { return true; }
+
+  ConstrainedHtmlDialogBrowserTestHandler* test_handler() {
+    return test_handler_.get();
+  }
+
+ private:
+  scoped_ptr<ConstrainedHtmlDialogBrowserTestHandler> test_handler_;
+};
+
+class ConstrainedHtmlDialogBrowserTestObserver : public TabContentsObserver {
+ public:
+  explicit ConstrainedHtmlDialogBrowserTestObserver(TabContents* contents)
+      : TabContentsObserver(contents),
+        tab_destroyed_(false) {
+  }
+  virtual ~ConstrainedHtmlDialogBrowserTestObserver() {}
+
+  bool tab_destroyed() { return tab_destroyed_; }
+
+ private:
+  virtual void TabContentsDestroyed(TabContents* tab) {
+    tab_destroyed_ = true;
+  }
+
+  bool tab_destroyed_;
 };
 
 }  // namespace
 
 class ConstrainedHtmlDialogBrowserTest : public InProcessBrowserTest {
  public:
   ConstrainedHtmlDialogBrowserTest() {}
+
+ protected:
+  size_t GetConstrainedWindowCount(TabContentsWrapper* wrapper) const {
+    return wrapper->constrained_window_tab_helper()->constrained_window_count();
+  }
 };
 
 // Tests that opening/closing the constrained window won't crash it.
 IN_PROC_BROWSER_TEST_F(ConstrainedHtmlDialogBrowserTest, BasicTest) {
   // The delegate deletes itself.
   HtmlDialogUIDelegate* delegate = new TestHtmlDialogUIDelegate();
   TabContentsWrapper* wrapper = browser()->GetSelectedTabContentsWrapper();
-  ASSERT_TRUE(wrapper != NULL);
+  ASSERT_TRUE(wrapper);
 
-  ConstrainedHtmlUI::CreateConstrainedHtmlDialog(browser()->profile(),
-                                                 delegate,
-                                                 wrapper);
+  ConstrainedWindow* window =
+      ConstrainedHtmlUI::CreateConstrainedHtmlDialog(browser()->profile(),
+                                                     delegate,
+                                                     wrapper);
+  EXPECT_TRUE(window);
+  EXPECT_EQ(1U, GetConstrainedWindowCount(wrapper));
+}
 
-  ASSERT_EQ(1U, wrapper->constrained_window_tab_helper()->
-            constrained_window_count());
+// Tests that ReleaseTabContentsOnDialogClose() works.
+IN_PROC_BROWSER_TEST_F(ConstrainedHtmlDialogBrowserTest,
+                       ReleaseTabContentsOnDialogClose) {
+  // The delegate deletes itself.
+  TestHtmlDialogUIDelegate* delegate = new TestHtmlDialogUIDelegate();
+  TabContentsWrapper* wrapper = browser()->GetSelectedTabContentsWrapper();
+  ASSERT_TRUE(wrapper);
+
+  TabContentsWrapper* new_tab =
+      ConstrainedHtmlUI::CreateConstrainedPrintPreviewHtmlUI(
+          browser()->profile(),
+          delegate,
+          wrapper);
+  ASSERT_TRUE(new_tab);
+  ASSERT_EQ(1U, GetConstrainedWindowCount(wrapper));
+
+  ConstrainedHtmlDialogBrowserTestObserver observer(new_tab->tab_contents());
+  ConstrainedHtmlDialogBrowserTestHandler* handler = delegate->test_handler();
+  ConstrainedHtmlUI* constrained_ui = handler->constrained_ui();
+  ASSERT_TRUE(constrained_ui);
+  ConstrainedHtmlUIDelegate* constrained_delegate =
+      constrained_ui->GetConstrainedDelegate();
+  ASSERT_TRUE(constrained_delegate);
+  constrained_delegate->ReleaseTabContentsOnDialogClose();
+  constrained_delegate->OnDialogCloseFromWebUI();
+
+  ASSERT_FALSE(observer.tab_destroyed());
+  EXPECT_EQ(0U, GetConstrainedWindowCount(wrapper));
+  delete new_tab;

[Paweł Hajdan Jr., 2011/10/11 22:16:48]

Why not scoped_ptr? Otherwise if any of ASSERTs fail you got a leak.

[Lei Zhang, 2011/10/11 23:41:25]

Done.

+  EXPECT_TRUE(observer.tab_destroyed());
 }