Chrome side of the fix for http://b/issue?id=1694574, which is a bug caused w...

chrome/browser/external_tab_container.cc

 // Copyright (c) 2006-2008 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/external_tab_container.h"
 
 #include <string>
 
 #include "app/l10n_util.h"
 #include "app/win_util.h"
 #include "base/logging.h"
 #include "base/win_util.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/load_notification_details.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/provisional_load_details.h"
 #include "chrome/browser/views/tab_contents/render_view_context_menu_external_win.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/views/tab_contents/tab_contents_container.h"
 #include "chrome/common/bindings_policy.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/test/automation/automation_messages.h"
 
 #include "grit/generated_resources.h"
 
 static const wchar_t kWindowObjectKey[] = L"ChromeWindowObject";
 
+ExternalTabContainer::PendingTabs ExternalTabContainer::pending_tabs_;
+
 ExternalTabContainer::ExternalTabContainer(
     AutomationProvider* automation, AutomationResourceMessageFilter* filter)
     : automation_(automation),
       tab_contents_(NULL),
       tab_contents_container_(NULL),
       tab_handle_(0),
       ignore_next_load_notification_(false),
       automation_resource_message_filter_(filter),
       load_requests_via_automation_(false),
       handle_top_level_requests_(false) {
 }
 
 ExternalTabContainer::~ExternalTabContainer() {
-  Uninitialize(GetNativeView());
+  Uninitialize();
 }
 
 bool ExternalTabContainer::Init(Profile* profile,
                                 HWND parent,
                                 const gfx::Rect& bounds,
                                 DWORD style,
                                 bool load_requests_via_automation,
                                 bool handle_top_level_requests,
                                 TabContents* existing_contents) {
   if (IsWindow()) {
@@ skipping 20 matching lines @@
     // Customize our profile.
     // TODO(joshia): If we are loading requests via automation
     // and handling cookies in automation then it's probably better to
     // use OTR profile so that cookies are not persisted in chrome.
     automation_profile_.reset(new AutomationProfileImpl);
     automation_profile_->Initialize(profile,
                                     automation_resource_message_filter_);
     profile = automation_profile_.get();
   }
 
-  if (existing_contents)
+  if (existing_contents) {
     tab_contents_ = existing_contents;
-  else
+    tab_contents_->controller().set_profile(profile);
+  } else {
     tab_contents_ = new TabContents(profile, NULL, MSG_ROUTING_NONE, NULL);
+  }
 
   tab_contents_->set_delegate(this);
+
   tab_contents_->GetMutableRendererPrefs()->browser_handles_top_level_requests =
       handle_top_level_requests;
 
   if (!existing_contents) {
     tab_contents_->render_view_host()->AllowBindings(
         BindingsPolicy::EXTERNAL_HOST);
   }
 
   // Create a TabContentsContainer to handle focus cycling using Tab and
   // Shift-Tab.
@@ skipping 32 matching lines @@
   if (parent)
     SetParent(GetNativeView(), parent);
 
   ::ShowWindow(tab_contents_->GetNativeView(), SW_SHOWNA);
 
   disabled_context_menu_ids_.push_back(
       IDS_CONTENT_CONTEXT_OPENLINKOFFTHERECORD);
   return true;
 }
 
+void ExternalTabContainer::Uninitialize() {
+  registrar_.RemoveAll();
+  if (tab_contents_) {
+    NotificationService::current()->Notify(
+        NotificationType::EXTERNAL_TAB_CLOSED,
+        Source<NavigationController>(&tab_contents_->controller()),
+        Details<ExternalTabContainer>(this));
+
+    delete tab_contents_;
+    tab_contents_ = NULL;
+  }
+}
+
+bool ExternalTabContainer::Reinitialize(
+    AutomationProvider* automation_provider,
+    AutomationResourceMessageFilter* filter) {
+  if (!automation_provider || !filter) {
+    NOTREACHED();
+    return false;
+  }
+
+  automation_ = automation_provider;
+  automation_resource_message_filter_ = filter;
+
+  if (load_requests_via_automation_) {
+    RenderViewHost* rvh = tab_contents_->render_view_host();
+    if (rvh) {
+      AutomationResourceMessageFilter::RegisterRenderView(
+          rvh->process()->id(), rvh->routing_id(),
+          tab_handle_, automation_resource_message_filter_);
+    }
+
+    DCHECK(automation_profile_.get() != NULL);
+    Profile* profile = tab_contents_->profile()->GetOriginalProfile();
+    DCHECK(profile != NULL);
+    automation_profile_->Initialize(profile, filter);
+  }
+
+  return true;
+}
+
 void ExternalTabContainer::ProcessUnhandledAccelerator(const MSG& msg) {
   DefWindowProc(msg.hwnd, msg.message, msg.wParam, msg.lParam);
 }
 
 void ExternalTabContainer::FocusThroughTabTraversal(bool reverse) {
   DCHECK(tab_contents_);
   if (tab_contents_) {
     static_cast<TabContents*>(tab_contents_)->Focus();
     static_cast<TabContents*>(tab_contents_)->FocusThroughTabTraversal(reverse);
   }
@@ skipping 70 matching lines @@
       Browser::BuildPopupWindowHelper(source, new_contents, initial_pos,
                                       Browser::TYPE_POPUP,
                                       tab_contents_->profile(), true);
       break;
     }
 
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB: {
       DCHECK(automation_ != NULL);
 
-      ExternalTabContainer* new_container =
-          new ExternalTabContainer(automation_,
-                                   automation_resource_message_filter_);
-      bool result = new_container->Init(automation_profile_.get(),
-                                        NULL,
-                                        initial_pos,
-                                        WS_CHILD,
-                                        load_requests_via_automation_,
-                                        handle_top_level_requests_,
-                                        new_contents);
-      DCHECK(result);
-      result = automation_->AddExternalTab(new_container);
-      DCHECK(result);
+      scoped_refptr<ExternalTabContainer> new_container =
+          new ExternalTabContainer(NULL, NULL);
 
-      automation_->Send(new AutomationMsg_AttachExternalTab(
-          0, tab_handle_, new_container->tab_handle(),
-          new_container->GetNativeView(), new_contents->GetNativeView(),
-          disposition));
+      // Make sure that ExternalTabContainer instance is initialized with
+      // an unwrapped Profile.
+      bool result = new_container->Init(
+          new_contents->profile()->GetOriginalProfile(),
+          NULL,
+          initial_pos,
+          WS_CHILD,
+          load_requests_via_automation_,
+          handle_top_level_requests_,
+          new_contents);
+
+      if (result) {
+        pending_tabs_[reinterpret_cast<intptr_t>(new_container.get())] =
+            new_container;
+
+        automation_->Send(new AutomationMsg_AttachExternalTab(
+            0,
+            tab_handle_,
+            reinterpret_cast<intptr_t>(new_container.get()),
+            disposition));
+      } else {
+        NOTREACHED();
+      }
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 void ExternalTabContainer::ActivateContents(TabContents* contents) {
@@ skipping 186 matching lines @@
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ExternalTabContainer, views::WidgetWin overrides:
 
+LRESULT ExternalTabContainer::OnCreate(LPCREATESTRUCT create_struct) {
+  LRESULT result = views::WidgetWin::OnCreate(create_struct);
+  if (result == 0) {
+    // Grab a reference here which will be released in OnFinalMessage
+    AddRef();
+  }
+  return result;
+}
+
 void ExternalTabContainer::OnDestroy() {
-  Uninitialize(GetNativeView());
+  Uninitialize();
   WidgetWin::OnDestroy();
   if (browser_.get()) {
     ::DestroyWindow(browser_->window()->GetNativeHandle());
   }
 }
 
+void ExternalTabContainer::OnFinalMessage(HWND window) {
+  // Release the reference which we grabbed in WM_CREATE.
+  Release();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ExternalTabContainer, private:
-
-void ExternalTabContainer::Uninitialize(HWND window) {
-  registrar_.RemoveAll();
-  if (tab_contents_) {
-    NotificationService::current()->Notify(
-        NotificationType::EXTERNAL_TAB_CLOSED,
-        Source<NavigationController>(&tab_contents_->controller()),
-        Details<ExternalTabContainer>(this));
-
-    delete tab_contents_;
-    tab_contents_ = NULL;
-  }
-}
-
 bool ExternalTabContainer::ProcessUnhandledKeyStroke(HWND window,
                                                      UINT message,
                                                      WPARAM wparam,
                                                      LPARAM lparam) {
   if (!automation_) {
     return false;
   }
   if ((wparam == VK_TAB) && !win_util::IsCtrlPressed()) {
     // Tabs are handled separately (except if this is Ctrl-Tab or
     // Ctrl-Shift-Tab)
@@ skipping 37 matching lines @@
 
   nav_info->navigation_type = nav_type;
   nav_info->relative_offset = relative_offset;
   nav_info->navigation_index =
       tab_contents_->controller().GetCurrentEntryIndex();
   nav_info->title =  UTF16ToWideHack(entry->title());
   nav_info->url = entry->url();
   return true;
 }
 
+ExternalTabContainer* ExternalTabContainer::RemovePendingTab(intptr_t cookie) {
+  PendingTabs::iterator index = pending_tabs_.find(cookie);
+  if (index != pending_tabs_.end()) {
+    scoped_refptr<ExternalTabContainer> container = (*index).second;
+    pending_tabs_.erase(index);
+    return container.release();
+  }
+
+  NOTREACHED() << "Failed to find ExternalTabContainer for cookie: "
+               << cookie;
+  return NULL;
+}
+