Allow TabContentsDelegate classes to specify whether InfoBars are ena…

…bled.

Allow ChromeFrame to pass infobar enabled parameter to ExternalTabContainer.
BUG=2444936

Patch contributed by ericdingle@google.com
Original review at http://codereview.chromium.org/890005


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@42366 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/automation/automation_provider_win.cc

@@ -325,7 +325,7 @@ void AutomationProvider::CreateExternalTab(
   external_tab_container->Init(profile, settings.parent, settings.dimensions,
       settings.style, settings.load_requests_via_automation,
       settings.handle_top_level_requests, NULL, settings.initial_url,
-      settings.referrer);
+      settings.referrer, settings.infobars_enabled);
 
   if (AddExternalTab(external_tab_container)) {
     TabContents* tab_contents = external_tab_container->tab_contents();

chrome/browser/external_tab_container.cc

@@ -54,7 +54,8 @@ ExternalTabContainer::ExternalTabContainer(
       external_method_factory_(this),
       enabled_extension_automation_(false),
       waiting_for_unload_event_(false),
-      pending_(false) {
+      pending_(false),
+      infobars_enabled_(true) {
 }
 
 ExternalTabContainer::~ExternalTabContainer() {
@@ -69,14 +70,16 @@ bool ExternalTabContainer::Init(Profile* profile,
                                 bool handle_top_level_requests,
                                 TabContents* existing_contents,
                                 const GURL& initial_url,
-                                const GURL& referrer) {
+                                const GURL& referrer,
+                                bool infobars_enabled) {
   if (IsWindow()) {
     NOTREACHED();
     return false;
   }
 
   load_requests_via_automation_ = load_requests_via_automation;
   handle_top_level_requests_ = handle_top_level_requests;
+  infobars_enabled_ = infobars_enabled;
 
   set_window_style(WS_POPUP | WS_CLIPCHILDREN);
   views::WidgetWin::Init(NULL, bounds);
@@ -351,7 +354,8 @@ void ExternalTabContainer::AddNewContents(TabContents* source,
       handle_top_level_requests_,
       new_contents,
       GURL(),
-      GURL());
+      GURL(),
+      true);
 
   if (result) {
     uintptr_t cookie = reinterpret_cast<uintptr_t>(new_container.get());
@@ -379,6 +383,10 @@ void ExternalTabContainer::TabContentsCreated(TabContents* new_contents) {
   RegisterRenderViewHostForAutomation(rvh, true);
 }
 
+bool ExternalTabContainer::infobars_enabled() {
+  return infobars_enabled_;
+}
+
 void ExternalTabContainer::ActivateContents(TabContents* contents) {
 }
 

chrome/browser/external_tab_container.h

@@ -65,7 +65,8 @@ class ExternalTabContainer : public TabContentsDelegate,
             bool handle_top_level_requests,
             TabContents* existing_tab_contents,
             const GURL& initial_url,
-            const GURL& referrer);
+            const GURL& referrer,
+            bool infobars_enabled);
 
   // Unhook the keystroke listener and notify about the closing TabContents.
   // This function gets called from three places, which is fine.
@@ -202,6 +203,8 @@ class ExternalTabContainer : public TabContentsDelegate,
 
   virtual void TabContentsCreated(TabContents* new_contents);
 
+  virtual bool infobars_enabled();
+
  protected:
   // Overridden from views::WidgetWin:
   virtual LRESULT OnCreate(LPCREATESTRUCT create_struct);
@@ -325,6 +328,9 @@ class ExternalTabContainer : public TabContentsDelegate,
   // from the host.
   bool pending_;
 
+  // Set to true if the ExternalTabContainer if infobars should be enabled.
+  bool infobars_enabled_;
+
   DISALLOW_COPY_AND_ASSIGN(ExternalTabContainer);
 };
 

chrome/browser/tab_contents/tab_contents.cc

@@ -951,6 +951,11 @@ bool TabContents::FocusLocationBarByDefault() {
 }
 
 void TabContents::AddInfoBar(InfoBarDelegate* delegate) {
+  if (delegate_ && !delegate_->infobars_enabled()) {
+    delegate->InfoBarClosed();
+    return;
+  }
+
   // Look through the existing InfoBarDelegates we have for a match. If we've
   // already got one that matches, then we don't add the new one.
   for (int i = 0; i < infobar_delegate_count(); ++i) {
@@ -977,6 +982,10 @@ void TabContents::AddInfoBar(InfoBarDelegate* delegate) {
 }
 
 void TabContents::RemoveInfoBar(InfoBarDelegate* delegate) {
+  if (delegate_ && !delegate_->infobars_enabled()) {
+    return;
+  }
+
   std::vector<InfoBarDelegate*>::iterator it =
       find(infobar_delegates_.begin(), infobar_delegates_.end(), delegate);
   if (it != infobar_delegates_.end()) {
@@ -997,6 +1006,11 @@ void TabContents::RemoveInfoBar(InfoBarDelegate* delegate) {
 
 void TabContents::ReplaceInfoBar(InfoBarDelegate* old_delegate,
                                  InfoBarDelegate* new_delegate) {
+  if (delegate_ && !delegate_->infobars_enabled()) {
+    new_delegate->InfoBarClosed();
+    return;
+  }
+
   std::vector<InfoBarDelegate*>::iterator it =
       find(infobar_delegates_.begin(), infobar_delegates_.end(), old_delegate);
   DCHECK(it != infobar_delegates_.end());

chrome/browser/tab_contents/tab_contents_delegate.h

@@ -283,6 +283,9 @@ class TabContentsDelegate : public AutomationResourceRoutingDelegate {
   // typically happens when popups are created.
   virtual void TabContentsCreated(TabContents* new_contents) {}
 
+  // Returns whether infobars are enabled. Overrideable by child classes.
+  virtual bool infobars_enabled() { return true; }
+
  protected:
   ~TabContentsDelegate() {}
 };

chrome/test/automation/automation_messages.h

@@ -356,6 +356,7 @@ struct ExternalTabSettings {
   bool handle_top_level_requests;
   GURL initial_url;
   GURL referrer;
+  bool infobars_enabled;
 };
 
 // Traits for ExternalTabSettings structure to pack/unpack.

chrome_frame/chrome_active_document.cc

@@ -1004,7 +1004,8 @@ bool ChromeActiveDocument::LaunchUrl(const std::wstring& url,
 
   automation_client_->SetUrlFetcher(&url_fetcher_);
 
-  if (InitializeAutomation(GetHostProcessName(false), L"", IsIEInPrivate()))
+  if (InitializeAutomation(GetHostProcessName(false), L"", IsIEInPrivate(),
+                           false))
     return true;
 
   return false;

chrome_frame/chrome_frame_activex.cc

@@ -447,7 +447,7 @@ HRESULT ChromeFrameActivex::IOleObject_SetClientSite(
     url_fetcher_.set_frame_busting(!is_privileged_);
     automation_client_->SetUrlFetcher(&url_fetcher_);
     if (!InitializeAutomation(profile_name, chrome_extra_arguments,
-                              IsIEInPrivate())) {
+                              IsIEInPrivate(), true)) {
       return E_FAIL;
     }
   }

chrome_frame/chrome_frame_automation.cc

@@ -450,24 +450,22 @@ ChromeFrameAutomationClient::~ChromeFrameAutomationClient() {
 
 bool ChromeFrameAutomationClient::Initialize(
     ChromeFrameDelegate* chrome_frame_delegate,
-    int automation_server_launch_timeout,
-    bool perform_version_check,
-    const std::wstring& profile_name,
-    const std::wstring& extra_chrome_arguments,
-    bool incognito) {
+    const ChromeFrameLaunchParams& chrome_launch_params) {
   DCHECK(!IsWindow());
   chrome_frame_delegate_ = chrome_frame_delegate;
+  chrome_launch_params_ = chrome_launch_params;
   ui_thread_id_ = PlatformThread::CurrentId();
 #ifndef NDEBUG
   // In debug mode give more time to work with a debugger.
   if (IsDebuggerPresent()) {
     // Don't use INFINITE (which is -1) or even MAXINT since we will convert
     // from milliseconds to microseconds when stored in a base::TimeDelta,
     // thus * 1000. An hour should be enough.
-    automation_server_launch_timeout = 60 * 60 * 1000;
+    chrome_launch_params_.automation_server_launch_timeout = 60 * 60 * 1000;
   } else {
-    DCHECK_LT(automation_server_launch_timeout, MAXINT / 2000);
-    automation_server_launch_timeout *= 2;
+    DCHECK_LT(chrome_launch_params_.automation_server_launch_timeout,
+              MAXINT / 2000);
+    chrome_launch_params_.automation_server_launch_timeout *= 2;
   }
 #endif  // NDEBUG
 
@@ -490,13 +488,9 @@ bool ChromeFrameAutomationClient::Initialize(
   // InitializeComplete is called successfully.
   init_state_ = INITIALIZING;
 
-  chrome_launch_params_.automation_server_launch_timeout =
-      automation_server_launch_timeout;
-  chrome_launch_params_.profile_name = profile_name;
-  chrome_launch_params_.extra_chrome_arguments = extra_chrome_arguments;
-  chrome_launch_params_.perform_version_check = perform_version_check;
-  chrome_launch_params_.url = navigate_after_initialization_ ? GURL() : url_;
-  chrome_launch_params_.incognito_mode = incognito;
+  if (navigate_after_initialization_) {
+    chrome_launch_params_.url = url_;
+  }
 
   proxy_factory_->GetAutomationServer(
       static_cast<ProxyFactory::LaunchDelegate*>(this),
@@ -841,6 +835,7 @@ void ChromeFrameAutomationClient::CreateExternalTab() {
     handle_top_level_requests_,
     chrome_launch_params_.url,
     chrome_launch_params_.referrer,
+    !chrome_launch_params_.is_widget_mode  // Infobars disabled in widget mode.
   };
 
   THREAD_SAFE_UMA_HISTOGRAM_CUSTOM_COUNTS(

chrome_frame/chrome_frame_automation.h

@@ -88,6 +88,7 @@ struct ChromeFrameLaunchParams {
   std::wstring extra_chrome_arguments;
   bool perform_version_check;
   bool incognito_mode;
+  bool is_widget_mode;
 };
 
 // We must create and destroy automation proxy in a thread with a message loop.
@@ -158,11 +159,7 @@ class ChromeFrameAutomationClient
 
   // Called from UI thread.
   virtual bool Initialize(ChromeFrameDelegate* chrome_frame_delegate,
-                          int automation_server_launch_timeout,
-                          bool perform_version_check,
-                          const std::wstring& profile_name,
-                          const std::wstring& extra_chrome_arguments,
-                          bool incognito);
+                          const ChromeFrameLaunchParams& chrome_launch_params);
   void Uninitialize();
 
   virtual bool InitiateNavigation(const std::string& url,

chrome_frame/chrome_frame_npapi.cc

@@ -320,7 +320,7 @@ bool ChromeFrameNPAPI::Initialize(NPMIMEType mime_type, NPP instance,
   // TODO(stoyan): Ask host for specific interface whether to honor
   // host's in-private mode.
   return InitializeAutomation(profile_name, extra_arguments,
-                              GetBrowserIncognitoMode());
+                              GetBrowserIncognitoMode(), true);
 }
 
 void ChromeFrameNPAPI::Uninitialize() {

chrome_frame/chrome_frame_npapi_unittest.cc

@@ -20,6 +20,7 @@ namespace {
 
 using ::testing::_;
 using ::testing::Eq;
+using ::testing::Field;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrEq;
@@ -80,9 +81,7 @@ class MockNPAPI: public ChromeFrameNPAPI {
 
 class MockAutomationClient: public ChromeFrameAutomationClient {
  public:
-  MOCK_METHOD6(Initialize, bool(ChromeFrameDelegate*, int, bool,
-                                const std::wstring&, const std::wstring&,
-                                bool));
+  MOCK_METHOD2(Initialize, bool(ChromeFrameDelegate*, ChromeFrameLaunchParams));
   MOCK_METHOD1(SetEnableExtensionAutomation,
                void(const std::vector<std::string>&));  // NOLINT
 };
@@ -127,7 +126,14 @@ class TestNPAPIPrivilegedApi: public ::testing::Test {
     EXPECT_CALL(*mock_proxy, Initialize(_, _)).WillRepeatedly(Return(false));
 
     EXPECT_CALL(*mock_automation,
-        Initialize(_, _, true, StrEq(profile_name), StrEq(extra_args), false))
+        Initialize(_, AllOf(
+            Field(&ChromeFrameLaunchParams::perform_version_check, true),
+            Field(&ChromeFrameLaunchParams::profile_name,
+                  StrEq(profile_name)),
+            Field(&ChromeFrameLaunchParams::extra_chrome_arguments,
+                  StrEq(extra_args)),
+            Field(&ChromeFrameLaunchParams::incognito_mode, is_incognito),
+            Field(&ChromeFrameLaunchParams::is_widget_mode, true))))
         .WillOnce(Return(true));
 
     if (expect_privilege_check) {

chrome_frame/chrome_frame_plugin.h

@@ -51,14 +51,22 @@ END_MSG_MAP()
 
   bool InitializeAutomation(const std::wstring& profile_name,
                             const std::wstring& extra_chrome_arguments,
-                            bool incognito) {
+                            bool incognito, bool is_widget_mode) {
     DCHECK(IsValid());
     // We don't want to do incognito when privileged, since we're
     // running in browser chrome or some other privileged context.
     bool incognito_mode = !is_privileged_ && incognito;
-    return automation_client_->Initialize(this, kCommandExecutionTimeout, true,
-                                          profile_name, extra_chrome_arguments,
-                                          incognito_mode);
+    ChromeFrameLaunchParams chrome_launch_params = {
+      kCommandExecutionTimeout,
+      GURL(),
+      GURL(),
+      profile_name,
+      extra_chrome_arguments,
+      true,
+      incognito_mode,
+      is_widget_mode
+    };
+    return automation_client_->Initialize(this, chrome_launch_params);
   }
 
   // ChromeFrameDelegate implementation