Test the feasibility of turning Chrome into a multi-process ActiveX control

chrome/browser/browser.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 <windows.h>
 #include <shellapi.h>
 
 #include "chrome/browser/browser.h"
 
 #include "base/command_line.h"
@@ skipping 132 matching lines @@
     : type_(type),
       profile_(profile),
       window_(NULL),
       tabstrip_model_(this, profile),
       controller_(this),
       toolbar_model_(this),
       chrome_updater_factory_(this),
       is_attempting_to_close_browser_(false),
       override_maximized_(false),
       method_factory_(this),
-      idle_task_(new BrowserIdleTimer) {
+      idle_task_(new BrowserIdleTimer),
+      parent_hwnd_(NULL) {
   tabstrip_model_.AddObserver(this);
 
   NotificationService::current()->AddObserver(
       this, NOTIFY_SSL_STATE_CHANGED, NotificationService::AllSources());
 
   InitCommandState();
   BrowserList::AddBrowser(this);
 
   encoding_auto_detect_.Init(prefs::kWebKitUsesUniversalDetector,
                              profile_->GetPrefs(), NULL);
@@ skipping 60 matching lines @@
 
 // static
 Browser* Browser::CreateForApp(const std::wstring& app_name,
                                Profile* profile) {
   Browser* browser = new Browser(BrowserType::APPLICATION, profile);
   browser->app_name_ = app_name;
   browser->CreateBrowserWindow();
   return browser;
 }
 
+// static
+Browser* Browser::CreateForEmbedded(HWND parent_hwnd,
+                                    gfx::Rect& rect,
+                                    Profile* profile) {
+  Browser* browser = new Browser(BrowserType::EMBEDDED, profile);
+  browser->set_parent_hwnd(parent_hwnd);
+  browser->set_override_bounds(rect);
+  browser->CreateBrowserWindow();
+  return browser;
+}
+
 void Browser::CreateBrowserWindow() {
   DCHECK(!window_);
   window_ = BrowserWindow::CreateBrowserWindow(this);
 
   // Show the First Run information bubble if we've been told to.
   PrefService* local_state = g_browser_process->local_state();
   if (local_state->IsPrefRegistered(prefs::kShouldShowFirstRunBubble) &&
       local_state->GetBoolean(prefs::kShouldShowFirstRunBubble)) {
     // Reset the preference so we don't show the bubble for subsequent windows.
     local_state->ClearPref(prefs::kShouldShowFirstRunBubble);
@@ skipping 63 matching lines @@
 std::wstring Browser::GetWindowPlacementKey() const {
   std::wstring name(prefs::kBrowserWindowPlacement);
   if (!app_name_.empty()) {
     name.append(L"_");
     name.append(app_name_);
   }
   return name;
 }
 
 bool Browser::ShouldSaveWindowPlacement() const {
-  // We don't save window position for popups.
-  return type() != BrowserType::BROWSER;
+  // We don't save window position for popups for embedded windows.
+  return type() != BrowserType::BROWSER && type() != BrowserType::EMBEDDED;
 }
 
 void Browser::SaveWindowPlacement(const gfx::Rect& bounds, bool maximized) {
   // Save to the session storage service, used when reloading a past session.
   // Note that we don't want to be the ones who cause lazy initialization of
   // the session service. This function gets called during initial window
   // showing, and we don't want to bring in the session service this early.
   if (profile()->HasSessionService()) {
     SessionService* session_service = profile()->GetSessionService();
     if (session_service)
@@ skipping 361 matching lines @@
 
   const TabRestoreService::HistoricalTab& tab = tabs.front();
   AddRestoredTab(tab.navigations, tab_count(), tab.current_navigation_index,
                  true);
   service->RemoveHistoricalTabById(tab.id);
 }
 
 void Browser::ConvertPopupToTabbedBrowser() {
   UserMetrics::RecordAction(L"ShowAsTab", profile_);
 
-  if (type() != BrowserType::BROWSER) {
+  if (type() != BrowserType::BROWSER && type() != BrowserType::EMBEDDED) {
     NOTREACHED();
     return;
   }
 
   int tab_strip_index = tabstrip_model_.selected_index();
   TabContents* contents = tabstrip_model_.DetachTabContentsAt(tab_strip_index);
   Browser* browser = Browser::Create(profile_);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
@@ skipping 558 matching lines @@
     // the right index (if tab 5 is selected and we right-click tab 1 we want
     // the new tab to appear in index position 2, not 6).
     if (tabstrip_model_.selected_index() != index)
       tabstrip_model_.SelectTabContentsAt(index, true);
     tabstrip_model_.AddTabContents(new_contents, index + 1,
                                    PageTransition::LINK, true);
   } else {
     Browser* browser = NULL;
     if (type_ == BrowserType::APPLICATION) {
       browser = Browser::CreateForApp(app_name_, profile_);
-    } else if (type_ == BrowserType::BROWSER) {
+    } else if (type_ == BrowserType::BROWSER || type_ == BrowserType::EMBEDDED) {
       browser = Browser::CreateForPopup(profile_);
     }
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
     HWND parent_hwnd = reinterpret_cast<HWND>(window_->GetNativeHandle());
     new_contents = browser->AddTabWithNavigationController(
@@ skipping 371 matching lines @@
 
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED() << "CloseContents called for tab not in our strip";
     return;
   }
   tabstrip_model_.CloseTabContentsAt(index);
 }
 
 void Browser::MoveContents(TabContents* source, const gfx::Rect& pos) {
-  if (type() != BrowserType::BROWSER) {
+  if (type() != BrowserType::BROWSER && type() != BrowserType::EMBEDDED) {
     NOTREACHED() << "moving invalid browser type";
     return;
   }
   window_->SetBounds(pos);
 }
 
 bool Browser::IsPopup(TabContents* source) {
   // A non-tabbed BROWSER is an unconstrained popup.
   return (type() == BrowserType::BROWSER);
 }
 
+bool Browser::IsEmbedded(TabContents* source) {
+  return (type() == BrowserType::EMBEDDED);
+}
+
 void Browser::ToolbarSizeChanged(TabContents* source, bool is_animating) {
   if (source == GetSelectedTabContents() || source == NULL) {
     // This will refresh the shelf if needed.
     window_->SelectedTabToolbarSizeChanged(is_animating);
   }
 }
 
 void Browser::URLStarredChanged(TabContents* source, bool starred) {
   if (source == GetSelectedTabContents())
     SetStarredButtonToggled(starred);
@@ skipping 652 matching lines @@
 
   // We need to register the window position pref.
   std::wstring window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append(L"_");
   window_pref.append(app_name);
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
 
   prefs->RegisterDictionaryPref(window_pref.c_str());
 }