Modifying extension automation so that it is done through a particular...

chrome/browser/extensions/extension_uitest.cc

 // Copyright (c) 2009 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 "base/command_line.h"
 #include "base/gfx/rect.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/automation/extension_automation_constants.h"
@@ skipping 37 matching lines @@
     functions_enabled_.push_back("*");
   }
 
   void set_functions_enabled(
       const std::vector<std::string>& functions_enabled) {
     functions_enabled_ = functions_enabled;
   }
 
   void SetUp() {
     ParentTestType::SetUp();
-    automation()->SetEnableExtensionAutomation(functions_enabled_);
+
+    AutomationProxyForExternalTab* proxy =
+        static_cast<AutomationProxyForExternalTab*>(automation());
+    HWND external_tab_container = NULL;
+    HWND tab_wnd = NULL;
+    tab_ = proxy->CreateTabWithHostWindow(false,
+        GURL(), &external_tab_container, &tab_wnd);
+
+    tab_->SetEnableExtensionAutomation(functions_enabled_);
   }
 
   void TearDown() {
-    automation()->SetEnableExtensionAutomation(std::vector<std::string>());
+    tab_->SetEnableExtensionAutomation(std::vector<std::string>());
+
+    AutomationProxyForExternalTab* proxy =
+        static_cast<AutomationProxyForExternalTab*>(automation());
+    proxy->DestroyHostWindow();
+    proxy->WaitForTabCleanup(tab_, action_max_timeout_ms());
+    EXPECT_FALSE(tab_->is_valid());
+    tab_.release();
+
     ParentTestType::TearDown();
   }
 
   void TestWithURL(const GURL& url) {
-    AutomationProxyForExternalTab* proxy =
+    EXPECT_TRUE(tab_->is_valid());
+    if (tab_) {
+      AutomationProxyForExternalTab* proxy =
         static_cast<AutomationProxyForExternalTab*>(automation());
-    HWND external_tab_container = NULL;
-    HWND tab_wnd = NULL;
-    scoped_refptr<TabProxy> tab(proxy->CreateTabWithHostWindow(false,
-        GURL(), &external_tab_container, &tab_wnd));
 
-    EXPECT_TRUE(tab->is_valid());
-    if (tab) {
       // Enter a message loop to allow the tab to be created
       proxy->WaitForNavigation(2000);
-      DoAdditionalPreNavigateSetup(tab.get());
+      DoAdditionalPreNavigateSetup(tab_.get());
 
       // We explicitly do not make this a toolstrip in the extension manifest,
       // so that the test can control when it gets loaded, and so that we test
       // the intended behavior that tabs should be able to show extension pages
       // (useful for development etc.)
-      tab->NavigateInExternalTab(url, GURL());
+      tab_->NavigateInExternalTab(url, GURL());
       EXPECT_TRUE(proxy->WaitForMessage(action_max_timeout_ms()));
-
-      proxy->DestroyHostWindow();
-      proxy->WaitForTabCleanup(tab, action_max_timeout_ms());
-      EXPECT_FALSE(tab->is_valid());
     }
   }
 
   // Override if you need additional stuff before we navigate the page.
   virtual void DoAdditionalPreNavigateSetup(TabProxy* tab) {
   }
 
  protected:
   // Extension API functions that we want to take over.  Defaults to all.
   std::vector<std::string> functions_enabled_;
+  scoped_refptr<TabProxy> tab_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionUITest);
 };
 
 // For tests that only need to check for a single postMessage
 // being received from the tab in Chrome.  These tests can send a message
 // to the tab before receiving the new message, but there will not be
 // a chance to respond by sending a message from the test to the tab after
 // the postMessage is received.
@@ skipping 403 matching lines @@
             proxy->event_count_.size());
   for (std::map<std::string, int>::iterator i = proxy->event_count_.begin();
       i != proxy->event_count_.end(); ++i) {
     const std::pair<std::string, int>& value = *i;
     ASSERT_EQ(1, value.second);
   }
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace