Make the bookmarks bar disappear when the load after the new tab page commits...

chrome/browser/tab_contents/render_view_host_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 #define CHROME_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 
 #include "base/basictypes.h"
+#include "base/scoped_ptr.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_observer.h"
 
+class DOMUI;
 class InterstitialPage;
 class NavigationController;
 class NavigationEntry;
 class Profile;
 class RenderViewHostDelegate;
 class RenderViewHostFactory;
 class RenderWidgetHostView;
 class SiteInstance;
 
 // Manages RenderViewHosts for a WebContents. Normally there is only one and
@@ skipping 18 matching lines @@
     virtual void BeforeUnloadFiredFromRenderManager(
         bool proceed, bool* proceed_to_fire_unload) = 0;
     virtual void DidStartLoadingFromRenderManager(
         RenderViewHost* render_view_host, int32 page_id) = 0;
     virtual void RenderViewGoneFromRenderManager(
         RenderViewHost* render_view_host) = 0;
     virtual void UpdateRenderViewSizeForRenderManager() = 0;
     virtual void NotifySwappedFromRenderManager() = 0;
     virtual NavigationController* GetControllerForRenderManager() = 0;
 
+    // Creates a DOMUI object for the given URL if one applies. Ownership of the
+    // returned pointer will be passed to the caller. If no DOMUI applies,
+    // returns NULL.
+    virtual DOMUI* CreateDOMUIForRenderManager(const GURL& url) = 0;
+
     // Returns the navigation entry of the current navigation, or NULL if there
     // is none.
     virtual NavigationEntry*
         GetLastCommittedNavigationEntryForRenderManager() = 0;
   };
 
   // The factory is optional. It is used by unit tests to supply custom render
   // view hosts. When NULL, the regular RenderViewHost will be created.
   //
   // Both delegate pointers must be non-NULL and are not owned by this class.
@@ skipping 26 matching lines @@
   }
 
   // Returns the view associated with the current RenderViewHost, or NULL if
   // there is no current one.
   RenderWidgetHostView* current_view() const {
     if (!render_view_host_)
       return NULL;
     return render_view_host_->view();
   }
 
+  // Returns the pending render view host, or NULL if there is no pending one.
+  RenderViewHost* pending_render_view_host() const {
+    return pending_render_view_host_;
+  }
+
+  // Returns the current committed DOM UI or NULL if none applies.
+  DOMUI* dom_ui() const { return dom_ui_.get(); }
+
+  // Returns the DOM UI for the pending navigation, or NULL of none applies.
+  DOMUI* pending_dom_ui() const { return pending_dom_ui_.get(); }
+
   // Called when we want to instruct the renderer to navigate to the given
   // navigation entry. It may create a new RenderViewHost or re-use an existing
   // one. The RenderViewHost to navigate will be returned. Returns NULL if one
   // could not be created.
   RenderViewHost* Navigate(const NavigationEntry& entry);
 
   // Instructs the various live views to stop. Called when the user directed the
   // page to stop loading.
   void Stop();
 
@@ skipping 81 matching lines @@
   // Helper method to create a pending RenderViewHost for a cross-site
   // navigation.
   bool CreatePendingRenderView(SiteInstance* instance);
 
   // Creates a RenderViewHost using render_view_factory_ (or directly, if the
   // factory is NULL).
   RenderViewHost* CreateRenderViewHost(SiteInstance* instance,
                                        int routing_id,
                                        base::WaitableEvent* modal_dialog_event);
 
-  // Replaces the currently shown render_view_host_ with the RenderViewHost in
-  // the field pointed to by |new_render_view_host|, and then NULLs the field.
-  // Callers should only pass pointers to the pending_render_view_host_,
-  // interstitial_render_view_host_, or original_render_view_host_ fields of
-  // this object.  If |destroy_after|, this method will call
-  // ScheduleDeferredDestroy on the previous render_view_host_.
-  void SwapToRenderView(RenderViewHost** new_render_view_host,
-                        bool destroy_after);
+  // Sets the pending RenderViewHost/DOMUI to be the active one. Note that this
+  // doesn't require the pending render_view_host_ pointer to be non-NULL, since
+  // there could be DOM UI switching as well. Call this for every commit.
+  void CommitPending();
 
   // Helper method to terminate the pending RenderViewHost.
-  void CancelPendingRenderView();
+  void CancelPending();
 
-  RenderViewHost* UpdateRendererStateNavigate(const NavigationEntry& entry);
+  RenderViewHost* UpdateRendererStateForNavigate(const NavigationEntry& entry);
 
   // Our delegate, not owned by us. Guaranteed non-NULL.
   Delegate* delegate_;
 
   // Whether a navigation requiring different RenderView's is pending. This is
   // either cross-site request is (in the new process model), or when required
   // for the view type (like view source versus not).
   bool cross_navigation_pending_;
 
   // Allows tests to create their own render view host types.
   RenderViewHostFactory* render_view_factory_;
 
   // Implemented by the owner of this class, this delegate is installed into all
   // the RenderViewHosts that we create.
   RenderViewHostDelegate* render_view_delegate_;
 
-  // Our RenderView host. This object is responsible for all communication with
+  // Our RenderView host and its associated DOM UI (if any, will be NULL for
+  // non-DOM-UI pages). This object is responsible for all communication with
   // a child RenderView instance.
   RenderViewHost* render_view_host_;
+  scoped_ptr<DOMUI> dom_ui_;
 
-  // A RenderViewHost used to load a cross-site page.  This remains hidden
-  // while a cross-site request is pending until it calls DidNavigate.
+  // A RenderViewHost used to load a cross-site page. This remains hidden
+  // while a cross-site request is pending until it calls DidNavigate. It may
+  // have an associated DOM UI, in which case the DOM UI pointer will be non-
+  // NULL.
+  //
+  // The pending_dom_ui may be non-NULL even when the pending_render_view_host_
+  // is. This will happen when we're transitioning between two DOM UI pages:
+  // the RVH won't be swapped, so the pending pointer will be unused, but there
+  // will be a pending DOM UI associated with the navigation.
   RenderViewHost* pending_render_view_host_;
+  scoped_ptr<DOMUI> pending_dom_ui_;
 
   // The intersitial page currently shown if any, not own by this class
   // (the InterstitialPage is self-owned, it deletes itself when hidden).
   InterstitialPage* interstitial_page_;
 
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostManager);
 };
 
 // The "details" for a NOTIFY_RENDER_VIEW_HOST_CHANGED notification. The old
 // host can be NULL when the first RenderViewHost is set.
 struct RenderViewHostSwitchedDetails {
   RenderViewHost* old_host;
   RenderViewHost* new_host;
 };
 
 #endif  // CHROME_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_