Pass result of blockage across content API when new tab blocked.

chrome/browser/ui/views/external_tab_container_win.cc

 // 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.
 
 #include "chrome/browser/ui/views/external_tab_container_win.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 443 matching lines @@
 void ExternalTabContainerWin::NavigationStateChanged(const WebContents* source,
                                                      unsigned changed_flags) {
   if (automation_) {
     NavigationInfo nav_info;
     if (InitNavigationInfo(&nav_info, content::NAVIGATION_TYPE_NAV_IGNORE, 0))
       automation_->Send(new AutomationMsg_NavigationStateChanged(
           tab_handle_, changed_flags, nav_info));
   }
 }
 
-void ExternalTabContainerWin::AddNewContents(WebContents* source,
+bool ExternalTabContainerWin::AddNewContents(WebContents* source,
                                              WebContents* new_contents,
                                              WindowOpenDisposition disposition,
                                              const gfx::Rect& initial_pos,
                                              bool user_gesture) {
   if (!automation_) {
     DCHECK(pending_);
     LOG(ERROR) << "Invalid automation provider. Dropping new contents notify";
     delete new_contents;
-    return;
+    return true;
   }
 
   scoped_refptr<ExternalTabContainerWin> new_container;
   // If the host is a browser like IE8, then the URL being navigated to in the
   // new tab contents could potentially navigate back to Chrome from a new
   // IE process. We support full tab mode only for IE and hence we use that as
   // a determining factor in whether the new ExternalTabContainer instance is
   // created as pending or not.
   if (!route_all_top_level_navigations_) {
     new_container = new ExternalTabContainerWin(NULL, NULL);
@@ skipping 20 matching lines @@
       tab_contents.get(),
       GURL(),
       GURL(),
       true,
       route_all_top_level_navigations_);
 
   if (result) {
     Profile* profile = tab_contents->profile();
     tab_contents.release();  // Ownership has been transferred.
     if (route_all_top_level_navigations_) {
-      return;
+      return true;
     }
     uintptr_t cookie = reinterpret_cast<uintptr_t>(new_container.get());
     pending_tabs_.Get()[cookie] = new_container;
     new_container->set_pending(true);
     new_container->set_is_popup_window(disposition == NEW_POPUP);
     AttachExternalTabParams attach_params_;
     attach_params_.cookie = static_cast<uint64>(cookie);
     attach_params_.dimensions = initial_pos;
     attach_params_.user_gesture = user_gesture;
     attach_params_.disposition = disposition;
     attach_params_.profile_name = WideToUTF8(
         profile->GetPath().DirName().BaseName().value());
     automation_->Send(new AutomationMsg_AttachExternalTab(
         tab_handle_, attach_params_));
   } else {
     NOTREACHED();
   }
+  return true;
 }
 
-void ExternalTabContainerWin::WebContentsCreated(WebContents* source_contents,
+bool ExternalTabContainerWin::WebContentsCreated(WebContents* source_contents,
                                                  int64 source_frame_id,
                                                  const GURL& target_url,
                                                  WebContents* new_contents) {
   if (!load_requests_via_automation_)
-    return;
+    return false;

[jam, 2012/09/04 19:50:46]

can you explain this? I'm not sure I understand why it's this way?

[Tom Sepez, 2012/09/04 20:46:16]

Not sure there's any upside to returning false here. I'll change it to be true.

 
   RenderViewHost* rvh = new_contents->GetRenderViewHost();
   DCHECK(rvh != NULL);
 
   // Register this render view as a pending render view, i.e. any network
   // requests initiated by this render view would be serviced when the
   // external host connects to the new external tab instance.
   RegisterRenderViewHostForAutomation(rvh, true);
+  return true;
 }
 
 void ExternalTabContainerWin::CloseContents(content::WebContents* source) {
   if (!automation_)
     return;
 
   if (unload_reply_message_) {
     AutomationMsg_RunUnloadHandlers::WriteReplyParams(unload_reply_message_,
                                                       true);
     automation_->Send(unload_reply_message_);
@@ skipping 704 matching lines @@
   if (params.disposition == CURRENT_TAB) {
     DCHECK(route_all_top_level_navigations_);
     forward_params.disposition = NEW_FOREGROUND_TAB;
   }
   WebContents* new_contents =
       ExternalTabContainerWin::OpenURLFromTab(source, forward_params);
   // support only one navigation for a dummy tab before it is killed.
   ::DestroyWindow(GetNativeView());
   return new_contents;
 }