Make browser_handles_top_level_requests synchronous.

chrome/browser/external_tab/external_tab_container_win.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTERNAL_TAB_EXTERNAL_TAB_CONTAINER_WIN_H_
 #define CHROME_BROWSER_EXTERNAL_TAB_EXTERNAL_TAB_CONTAINER_WIN_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/automation/automation_resource_message_filter.h"
 #include "chrome/browser/infobars/infobar_container.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
 #include "chrome/browser/ui/views/unhandled_keyboard_event_handler.h"
 #include "content/public/browser/navigation_type.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/referrer.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/views/widget/native_widget_win.h"
 
 class AutomationProvider;
 class Browser;
 class Profile;
 class TabContentsContainer;
 class TabContentsWrapper;
 class RenderViewContextMenuViews;
 struct NavigationInfo;
@@ skipping 78 matching lines @@
       gfx::NativeView native_window);
 
   // A helper method that retrieves the ExternalTabContainer object that
   // hosts the given tab window.
   static ExternalTabContainer* GetContainerForTab(HWND tab_window);
 
   // Overridden from content::WebContentsDelegate:
   virtual content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) OVERRIDE;
+  virtual bool ShouldIgnoreNavigation(
+      content::WebContents* source,
+      const GURL& url,
+      const content::Referrer& referrer,
+      WindowOpenDisposition disposition,
+      bool is_content_initiated,
+      content::PageTransition transition_type) OVERRIDE;
   virtual void NavigationStateChanged(const content::WebContents* source,
                                       unsigned changed_flags) OVERRIDE;
   virtual void AddNewContents(content::WebContents* source,
                               content::WebContents* new_contents,
                               WindowOpenDisposition disposition,
                               const gfx::Rect& initial_pos,
                               bool user_gesture) OVERRIDE;
   virtual void CloseContents(content::WebContents* source) OVERRIDE;
   virtual void MoveContents(content::WebContents* source,
                             const gfx::Rect& pos) OVERRIDE;
@@ skipping 138 matching lines @@
 
   // Sends over pending Open URL requests to the external host.
   void ServicePendingOpenURLRequests();
 
   // Scheduled as a task in ExternalTabContainer::Reinitialize
   void OnReinitialize();
 
   // Creates and initializes the view hierarchy for this ExternalTabContainer.
   void SetupExternalTabView();
 
+  // Send a URL open request to the external host.
+  content::WebContents* OpenUrlInExtenalHost(
+      content::WebContents* source,
+      const GURL& url,
+      WindowOpenDisposition disposition,
+      const content::Referrer& referrer);
+
   scoped_ptr<TabContentsWrapper> tab_contents_;
   scoped_refptr<AutomationProvider> automation_;
 
   content::NotificationRegistrar registrar_;
 
   // A view to handle focus cycling
   TabContentsContainer* tab_contents_container_;
 
   int tab_handle_;
   // A failed navigation like a 404 is followed in chrome with a success
@@ skipping 22 matching lines @@
   base::WeakPtrFactory<ExternalTabContainer> weak_factory_;
 
   // The URL request context to be used for this tab. Can be NULL.
   scoped_refptr<ChromeURLRequestContextGetter> request_context_;
 
   UnhandledKeyboardEventHandler unhandled_keyboard_event_handler_;
 
   // A mapping between accelerators and commands.
   std::map<ui::Accelerator, int> accelerator_table_;
 
+  struct PendingOpenUrlRequest {
+    GURL url;
+    WindowOpenDisposition disposition;
+    content::Referrer referrer;
+  };
   // Top level navigations received for a tab while it is waiting for an ack
   // from the external host go here. Scenario is a window.open executes on a
   // page in ChromeFrame. A new TabContents is created and the current
   // ExternalTabContainer is notified via AddNewContents. At this point we
   // send off an attach tab request to the host browser. Before the host
   // browser sends over the ack, we receive a top level URL navigation for the
   // new tab, which needs to be routed over the correct automation channel.
   // We receive the automation channel only when the external host acks the
   // attach tab request.
   // Contains the list of URL requests which are pending waiting for an ack
   // from the external host.
-  std::vector<content::OpenURLParams> pending_open_url_requests_;
+  std::vector<PendingOpenUrlRequest> pending_open_url_requests_;
 
   // Set to true if the ExternalTabContainer instance is waiting for an ack
   // from the host.
   bool pending_;
 
   views::FocusManager* focus_manager_;
 
   views::View* external_tab_view_;
 
   IPC::Message* unload_reply_message_;
@@ skipping 69 matching lines @@
     return false;
   }
 
   virtual void BeforeUnloadFired(content::WebContents* tab, bool proceed,
                                  bool* proceed_to_fire_unload) {
     NOTREACHED();
   }
 };
 
 #endif  // CHROME_BROWSER_EXTERNAL_TAB_EXTERNAL_TAB_CONTAINER_WIN_H_