Moved the following IPCs out of chrome into content where they are handled by

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"
@@ skipping 289 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_SaveURLAs, OnSaveURL)
     IPC_MESSAGE_HANDLER(ViewHostMsg_EnumerateDirectory, OnEnumerateDirectory)
     IPC_MESSAGE_HANDLER(ViewHostMsg_JSOutOfMemory, OnJSOutOfMemory)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RegisterProtocolHandler,
                         OnRegisterProtocolHandler)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RegisterIntentHandler,
                         OnRegisterIntentHandler)
     IPC_MESSAGE_HANDLER(ViewHostMsg_WebIntentDispatch,
                         OnWebIntentDispatch)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Find_Reply, OnFindReply)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_CrashedPlugin, OnCrashedPlugin)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   if (!message_is_ok) {
     UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_RVD"));
     GetRenderProcessHost()->ReceivedBadMessage();
   }
 
   return handled;
 }
@@ skipping 574 matching lines @@
 
 void TabContents::SetContentRestrictions(int restrictions) {
   content_restrictions_ = restrictions;
   delegate()->ContentRestrictionsChanged(this);
 }
 
 void TabContents::OnDidStartProvisionalLoadForFrame(int64 frame_id,
                                                     bool is_main_frame,
                                                     bool has_opener_set,
                                                     const GURL& url) {
+  delegate()->DidStartProvisionalLoadForFrame(this, frame_id, is_main_frame,

[jam, 2011/09/03 00:10:47]

is this new delegate method really necessary? the prerender tab helper already
implements TabContentsObserver, so can just implement TabContentsObserver to get
it can just watch DidStartProvisionalLoadForFrame notification

[ananta, 2011/09/03 00:43:23]

Thanks for pointing that out. Done.

+                                              has_opener_set, url);
+
   bool is_error_page = (url.spec() == chrome::kUnreachableWebDataURL);
   GURL validated_url(url);
   render_view_host()->FilterURL(ChildProcessSecurityPolicy::GetInstance(),
       GetRenderProcessHost()->id(), &validated_url);
 
   RenderViewHost* rvh =
       render_manager_.pending_render_view_host() ?
           render_manager_.pending_render_view_host() : render_view_host();
   // Notify observers about the start of the provisional load.
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
@@ skipping 225 matching lines @@
 
 void TabContents::OnFindReply(int request_id,
                               int number_of_matches,
                               const gfx::Rect& selection_rect,
                               int active_match_ordinal,
                               bool final_update) {
   delegate()->FindReply(this, request_id, number_of_matches, selection_rect,
                         active_match_ordinal, final_update);
 }
 
+void TabContents::OnCrashedPlugin(const FilePath& plugin_path) {
+  delegate()->CrashedPlugin(this, plugin_path);
+}
+
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading and calls the base implementation.
 void TabContents::SetIsLoading(bool is_loading,
                                LoadNotificationDetails* details) {
   if (is_loading == is_loading_)
     return;
 
   if (!is_loading) {
     load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE, string16());
     load_state_host_.clear();
@@ skipping 440 matching lines @@
     NotifyNavigationStateChanged(INVALIDATE_TITLE);
 }
 
 void TabContents::UpdateEncoding(RenderViewHost* render_view_host,
                                  const std::string& encoding) {
   set_encoding(encoding);
 }
 
 void TabContents::UpdateTargetURL(int32 page_id, const GURL& url) {
   if (delegate())
-    delegate()->UpdateTargetURL(this, url);
+    delegate()->UpdateTargetURL(this, page_id, url);
 }
 
 void TabContents::Close(RenderViewHost* rvh) {
   // The UI may be in an event-tracking loop, such as between the
   // mouse-down and mouse-up in text selection or a button click.
   // Defer the close until after tracking is complete, so that we
   // don't free objects out from under the UI.
   // TODO(shess): This could probably be integrated with the
   // IsDoingDrag() test below.  Punting for now because I need more
   // research to understand how this impacts platforms other than Mac.
@@ skipping 374 matching lines @@
 }
 
 void TabContents::SwapInRenderViewHost(RenderViewHost* rvh) {
   render_manager_.SwapInRenderViewHost(rvh);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }