Cross-process postMessage

content/browser/tab_contents/tab_contents.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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_context.h"
+#include "content/browser/browsing_instance_frame_id.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/debugger/devtools_manager_impl.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/download/download_stats.h"
+#include "content/browser/frame_map.h"
 #include "content/browser/host_zoom_map.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/intents/intents_host_impl.h"
 #include "content/browser/load_from_memory_cache_details.h"
 #include "content/browser/load_notification_details.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_request_details.h"
@@ skipping 129 matching lines @@
   params->current_history_list_offset = controller.last_committed_entry_index();
   params->current_history_list_length = controller.entry_count();
   params->url = entry.url();
   params->referrer = entry.referrer();
   params->transition = entry.transition_type();
   params->state = entry.content_state();
   params->navigation_type =
       GetNavigationType(controller.browser_context(), entry, reload_type);
   params->request_time = base::Time::Now();
   params->extra_headers = entry.extra_headers();
+  params->opener_browsing_instance_frame_id =
+      entry.opener_browsing_instance_frame_id();
   params->transferred_request_child_id =
       entry.transferred_global_request_id().child_id;
   params->transferred_request_request_id =
       entry.transferred_global_request_id().request_id;
 
   if (delegate)
     delegate->AddNavigationHeaders(params->url, &params->extra_headers);
 }
 
 }  // namespace
@@ skipping 30 matching lines @@
 #endif
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
       closed_by_user_gesture_(false),
       minimum_zoom_percent_(
           static_cast<int>(content::kMinimumZoomFactor * 100)),
       maximum_zoom_percent_(
           static_cast<int>(content::kMaximumZoomFactor * 100)),
       temporary_zoom_settings_(false),
       content_restrictions_(0),
-      view_type_(content::VIEW_TYPE_TAB_CONTENTS) {
+      view_type_(content::VIEW_TYPE_TAB_CONTENTS),
+      browsing_instance_frame_(
+          browser_context->frame_mapper().AllocateNewTopLevelFrameId()) {
   render_manager_.Init(browser_context, site_instance, routing_id);
 
+  // TODO(supersat): This is a hack and should be removed.
+  if (routing_id > 0) {
+    browser_context->frame_mapper().UpdateFrame(
+        browsing_instance_frame_, render_view_host()->process()->GetID(),
+        routing_id, -1 /* We don't know the frame id yet */);
+  }
+
   // We have the initial size of the view be based on the size of the passed in
   // tab contents (normally a tab from the same window).
   view_->CreateView(base_tab_contents ?
       base_tab_contents->view()->GetContainerSize() : gfx::Size());
 
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_host_manager_.reset(
       new JavaBridgeDispatcherHostManager(this));
 #endif
 }
@@ skipping 23 matching lines @@
       host->view()->WillWmDestroy();
   }
 #endif
 
   // OnCloseStarted isn't called in unit tests.
   if (!tab_close_start_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("Tab.Close",
         base::TimeTicks::Now() - tab_close_start_time_);
   }
 
+  // Remove the top-level frame from the frame mapper
+  browser_context()->frame_mapper().RemoveFrame(browsing_instance_frame_);
+  // TODO(supersat): This should probably remove the proxy on the other side
+  delete browsing_instance_frame_;
+
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, TabContentsDestroyed());
 
   set_delegate(NULL);
 }
 
 // TODO(cbentzel): Either remove the debugging code, or rename to SetDelegate.
 void TabContents::set_delegate(TabContentsDelegate* delegate) {
   if (delegate == delegate_)
     return;
   if (delegate_)
@@ skipping 1023 matching lines @@
     // page.
     UpdateTargetURL(details.entry->page_id(), GURL());
   }
 
   if (!details.is_in_page) {
     // Once the main frame is navigated, we're no longer considered to have
     // displayed insecure content.
     displayed_insecure_content_ = false;
   }
 
+  DLOG(WARNING) << "DidNavigateMainFramePostCommit: " <<
+      params.url << ", " << params.frame_id;
+  content::FrameMap& mapper = browser_context()->frame_mapper();
+  mapper.UpdateFrame(browsing_instance_frame_,
+                     render_view_host()->process()->GetID(),
+                     render_view_host()->routing_id(),
+                     params.frame_id);
+
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                     DidNavigateMainFrame(details, params));
 }
 
 void TabContents::DidNavigateAnyFramePostCommit(
     RenderViewHost* render_view_host,
     const content::LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   // If we navigate, reset JavaScript state. This does nothing to prevent
   // a malicious script from spamming messages, since the script could just
   // reload the page to stop blocking.
   if (dialog_creator_) {
     dialog_creator_->ResetJavaScriptState(this);
     dialog_creator_ = NULL;
   }
 
+  // TODO(supersat): Logging for debugging purposes only.
+  DLOG(WARNING) << "DidNavigateAnyFramePostCommit: "
+      << "bifi = " << browsing_instance_frame_->id()
+      << ", process id = " << render_view_host->process()->GetID()
+      << ", rvh route = " << render_view_host->routing_id()
+      << ", frame_id = " << params.frame_id << ", url = " <<
+      params.url;
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                     DidNavigateAnyFrame(details, params));
 }
 
 void TabContents::UpdateMaxPageIDIfNecessary(SiteInstance* site_instance,
                                              RenderViewHost* rvh) {
   // If we are creating a RVH for a restored controller, then we might
   // have more page IDs than the SiteInstance's current max page ID.  We must
   // make sure that the max page ID is larger than any restored page ID.
@@ skipping 401 matching lines @@
     int32 page_id) {
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       content::Source<TabContents>(this),
       content::Details<int>(&page_id));
 }
 
 void TabContents::RequestOpenURL(const GURL& url,
                                  const content::Referrer& referrer,
                                  WindowOpenDisposition disposition,
-                                 int64 source_frame_id) {
+                                 int64 source_frame_id,
+                                 int64 opener_browsing_instance_frame_id) {
   // Delegate to RequestTransferURL because this is just the generic
   // case where |old_request_id| is empty.
   RequestTransferURL(url, referrer, disposition, source_frame_id,
-                     GlobalRequestID());
+                     opener_browsing_instance_frame_id, GlobalRequestID());
 }
 
 void TabContents::RequestTransferURL(const GURL& url,
                                      const content::Referrer& referrer,
                                      WindowOpenDisposition disposition,
                                      int64 source_frame_id,
+                                     int64 opener_browsing_instance_frame_id,
                                      const GlobalRequestID& old_request_id) {
   TabContents* new_contents = NULL;
   content::PageTransition transition_type = content::PAGE_TRANSITION_LINK;
   if (render_manager_.web_ui()) {
     // When we're a Web UI, it will provide a page transition type for us (this
     // is so the new tab page can specify AUTO_BOOKMARK for automatically
     // generated suggestions).
     //
     // Note also that we hide the referrer for Web UI pages. We don't really
     // want web sites to see a referrer of "chrome://blah" (and some
     // chrome: URLs might have search terms or other stuff we don't want to
     // send to the site), so we send no referrer.
     OpenURLParams params(url, content::Referrer(), disposition,
         render_manager_.web_ui()->link_transition_type(),
         false /* is_renderer_initiated */);
     params.transferred_global_request_id = old_request_id;
     new_contents = OpenURL(params);
     transition_type = render_manager_.web_ui()->link_transition_type();
   } else {
     OpenURLParams params(url, referrer, disposition,
-        content::PAGE_TRANSITION_LINK, true /* is_renderer_initiated */);
+        content::PAGE_TRANSITION_LINK, true /* is_renderer_initiated */,
+        opener_browsing_instance_frame_id);
     params.transferred_global_request_id = old_request_id;
     new_contents = OpenURL(params);
   }
   if (new_contents) {
     // Notify observers.
     FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                       DidOpenRequestedURL(new_contents,
                                           url,
                                           referrer,
                                           disposition,
@@ skipping 279 matching lines @@
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(view()->GetContainerSize());
 }
 
 bool TabContents::GotResponseToLockMouseRequest(bool allowed) {
   return render_view_host() ?
       render_view_host()->GotResponseToLockMouseRequest(allowed) : false;
 }