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

chrome/browser/views/frame/browser_view.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 "base/command_line.h"
 
 #include "chrome/browser/views/frame/browser_view.h"
 
 #include "base/file_version_info.h"
 #include "base/time.h"
@@ skipping 134 matching lines @@
   GetStartupInfo(&si);
   return si.wShowWindow;
 }
 
 void BrowserView::WindowMoved() {
   // Cancel any tabstrip animations, some of them may be invalidated by the
   // window being repositioned.
   // Comment out for one cycle to see if this fixes dist tests.
   //tabstrip_->DestroyDragController();
 
-  status_bubble_->Reposition();
+  if(status_bubble_.get())
+    status_bubble_->Reposition();
 
   // Close the omnibox popup, if any.
   if (GetLocationBarView())
     GetLocationBarView()->location_entry()->ClosePopup();
 }
 
 gfx::Rect BrowserView::GetToolbarBounds() const {
-  return toolbar_->bounds();
+  if(toolbar_)
+    return toolbar_->bounds();
+  return gfx::Rect();
 }
 
 gfx::Rect BrowserView::GetClientAreaBounds() const {
   gfx::Rect container_bounds = contents_container_->bounds();
   container_bounds.Offset(x(), y());
   return container_bounds;
 }
 
 int BrowserView::GetTabStripHeight() const {
   return tabstrip_->GetPreferredHeight();
@@ skipping 104 matching lines @@
 
 bool BrowserView::SupportsWindowFeature(WindowFeature feature) const {
   return !!(FeaturesForBrowserType(browser_->type()) & feature);
 }
 
 // static
 unsigned int BrowserView::FeaturesForBrowserType(BrowserType::Type type) {
   unsigned int features = FEATURE_INFOBAR | FEATURE_DOWNLOADSHELF;
   if (type == BrowserType::TABBED_BROWSER)
     features |= FEATURE_TABSTRIP | FEATURE_TOOLBAR | FEATURE_BOOKMARKBAR;
-  if (type != BrowserType::APPLICATION)
+  if (type != BrowserType::APPLICATION && type != BrowserType::EMBEDDED)
     features |= FEATURE_LOCATIONBAR;
-  if (type != BrowserType::TABBED_BROWSER)
+  if (type != BrowserType::TABBED_BROWSER && type != BrowserType::EMBEDDED)
     features |= FEATURE_TITLEBAR;
   return features;
 }
 
 // static
 void BrowserView::RegisterBrowserViewPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kPluginMessageResponseTimeout,
                              kDefaultPluginMessageResponseTimeout);
   prefs->RegisterIntegerPref(prefs::kHungPluginDetectFrequency,
                              kDefaultHungPluginDetectFrequency);
@@ skipping 143 matching lines @@
   const bool ret = !!GetWindowPlacement(frame_->GetWindow()->GetHWND(), &wp);
   DCHECK(ret);
   return gfx::Rect(wp.rcNormalPosition);
 }
 
 bool BrowserView::IsMaximized() {
   return frame_->GetWindow()->IsMaximized();
 }
 
 ToolbarStarToggle* BrowserView::GetStarButton() const {
-  return toolbar_->star_button();
+  if(toolbar_)
+    return toolbar_->star_button();
+  return NULL;
 }
 
 LocationBarView* BrowserView::GetLocationBarView() const {
-  return toolbar_->GetLocationBarView();
+  if(toolbar_)
+    return toolbar_->GetLocationBarView();
+  return NULL;
 }
 
 GoButton* BrowserView::GetGoButton() const {
-  return toolbar_->GetGoButton();
+  if(toolbar_)
+    return toolbar_->GetGoButton();
+  return NULL;
 }
 
 BookmarkBarView* BrowserView::GetBookmarkBarView() {
   TabContents* current_tab = browser_->GetSelectedTabContents();
   if (!bookmark_bar_view_.get()) {
     bookmark_bar_view_.reset(new BookmarkBarView(current_tab->profile(),
                                                  browser_.get()));
     bookmark_bar_view_->SetParentOwned(false);
   } else {
     bookmark_bar_view_->SetProfile(current_tab->profile());
   }
   bookmark_bar_view_->SetPageNavigator(current_tab);
   return bookmark_bar_view_.get();
 }
 
 BrowserView* BrowserView::GetBrowserView() const {
   return NULL;
 }
 
 void BrowserView::UpdateToolbar(TabContents* contents,
                                 bool should_restore_state) {
-  toolbar_->Update(contents, should_restore_state);
+  if(toolbar_)
+    toolbar_->Update(contents, should_restore_state);
 }
 
 void BrowserView::FocusToolbar() {
-  toolbar_->RequestFocus();
+  if(toolbar_)
+    toolbar_->RequestFocus();
 }
 
 void BrowserView::DestroyBrowser() {
   // Explicitly delete the BookmarkBarView now. That way we don't have to
   // worry about the BookmarkBarView potentially outliving the Browser &
   // Profile.
   bookmark_bar_view_.reset();
   browser_.reset();
 }
 
@@ skipping 139 matching lines @@
   // TODO(beng): This should be called automatically by SetTabContents, but I
   //             am striving for parity now rather than cleanliness. This is
   //             required to make features like Duplicate Tab, Undo Close Tab,
   //             etc not result in sad tab.
   new_contents->DidBecomeSelected();
   if (BrowserList::GetLastActive() == browser_)
     new_contents->RestoreFocus();
 
   // Update all the UI bits.
   UpdateTitleBar();
-  toolbar_->SetProfile(new_contents->profile());
+  if(toolbar_)
+    toolbar_->SetProfile(new_contents->profile());
   UpdateToolbar(new_contents, true);
   UpdateUIForContents(new_contents);
 }
 
 void BrowserView::TabStripEmpty() {
   // Make sure all optional UI is removed before we are destroyed, otherwise
   // there will be consequences (since our view hierarchy will still have
   // references to freed views).
   UpdateUIForContents(NULL);
 }
@@ skipping 58 matching lines @@
                                       bool maximized,
                                       bool always_on_top) {
   if (browser_->ShouldSaveWindowPlacement()) {
     WindowDelegate::SaveWindowPlacement(bounds, maximized, always_on_top);
     browser_->SaveWindowPlacement(bounds, maximized);
   }
 }
 
 bool BrowserView::GetSavedWindowBounds(gfx::Rect* bounds) const {
   *bounds = browser_->GetSavedWindowBounds();
-  if (browser_->type() == BrowserType::BROWSER) {
-    // We are a popup window. The value passed in |bounds| represents two
+  if (browser_->type() == BrowserType::BROWSER || browser_->type() == BrowserType::EMBEDDED) {
+    // We are a popup or embedded window. The value passed in |bounds| represents two
     // pieces of information:
     // - the position of the window, in screen coordinates (outer position).
     // - the size of the content area (inner size).
     // We need to use these values to determine the appropriate size and
     // position of the resulting window.
     if (SupportsWindowFeature(FEATURE_TOOLBAR) ||
         SupportsWindowFeature(FEATURE_LOCATIONBAR)) {
       // If we're showing the toolbar, we need to adjust |*bounds| to include
       // its desired height, since the toolbar is considered part of the
       // window's client area as far as GetWindowBoundsForClientBounds is
@@ skipping 215 matching lines @@
   }
   return DragDropTypes::DRAG_NONE;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, private:
 
 void BrowserView::InitSystemMenu() {
   HMENU system_menu = GetSystemMenu(frame_->GetWindow()->GetHWND(), FALSE);
+  if(!system_menu)
+    return;
   system_menu_.reset(new Menu(system_menu));
   int insertion_index = std::max(0, system_menu_->ItemCount() - 1);
   // We add the menu items in reverse order so that insertion_index never needs
   // to change.
   if (browser_->type() == BrowserType::TABBED_BROWSER) {
     system_menu_->AddSeparator(insertion_index);
     system_menu_->AddMenuItemWithLabel(insertion_index, IDC_TASKMANAGER,
                                        l10n_util::GetString(IDS_TASKMANAGER));
     // If it's a regular browser window with tabs, we don't add any more items,
     // since it already has menus (Page, Chrome).
@@ skipping 354 matching lines @@
 
 // static
 void BrowserView::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_favicon_ = *rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
     initialized = true;
   }
 }