Move DidFailProvisionalLoad handling from RenderView(Host) to RenderFrame(Host).

content/browser/frame_host/render_frame_host_impl.h

 // Copyright 2013 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 CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/render_frame_host.h"
 
 class GURL;
+struct FrameHostMsg_DidFailProvisionalLoadWithError_Params;
 
 namespace base {
 class FilePath;
 }
 
 namespace content {
 
 class CrossProcessFrameConnector;
 class FrameTree;
 class FrameTreeNode;
@@ skipping 22 matching lines @@
 
   void Init();
   int routing_id() const { return routing_id_; }
   void OnCreateChildFrame(int new_frame_routing_id,
                           int64 parent_frame_id,
                           int64 frame_id,
                           const std::string& frame_name);
 
   RenderViewHostImpl* render_view_host() { return render_view_host_; }
   RenderFrameHostDelegate* delegate() { return delegate_; }
+  FrameTreeNode* frame_tree_node() { return frame_tree_node_; }

[Charlie Reis, 2014/01/06 18:13:35]

Do we need to expose FrameTreeNode yet?  Looks like we're just using it to get
to FrameTree, which we could expose instead.

[nasko, 2014/01/06 18:47:03]

Exposing FrameTreeNode seems more logical, since it is the object closest to RFH
and allows us to get to FrameTree if needed. Conceptually, RFH knows which
FrameTreeNode it belongs to, so it makes sense to expose it. I also believe we
will need it for other cases in the near future.

[Charlie Reis, 2014/01/06 19:07:17]

That's fair.  Let's leave it as is.

 
   // This function is called when this is a swapped out RenderFrameHost that
   // lives in the same process as the parent frame. The
   // |cross_process_frame_connector| allows the non-swapped-out
   // RenderFrameHost for a frame to communicate with the parent process
   // so that it may composite drawing data.
   //
   // Ownership is not transfered.
   void set_cross_process_frame_connector(
       CrossProcessFrameConnector* cross_process_frame_connector) {
@@ skipping 15 matching lines @@
 
  private:
   friend class TestRenderViewHost;
 
   // IPC Message handlers.
   void OnDetach(int64 parent_frame_id, int64 frame_id);
   void OnDidStartProvisionalLoadForFrame(int64 frame_id,
                                          int64 parent_frame_id,
                                          bool main_frame,
                                          const GURL& url);
+  void OnDidFailProvisionalLoadWithError(
+      const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params);
 
   bool is_swapped_out() { return is_swapped_out_; }
 
   // For now, RenderFrameHosts indirectly keep RenderViewHosts alive via a
   // refcount that calls Shutdown when it reaches zero.  This allows each
   // RenderFrameHostManager to just care about RenderFrameHosts, while ensuring
   // we have a RenderViewHost for each RenderFrameHost.
   // TODO(creis): RenderViewHost will eventually go away and be replaced with
   // some form of page context.
   RenderViewHostImpl* render_view_host_;
 
   RenderFrameHostDelegate* delegate_;
 
   // |cross_process_frame_connector_| passes messages from an out-of-process
   // child frame to the parent process for compositing.
   //
   // This is only non-NULL when this is the swapped out RenderFrameHost in
   // the same site instance as this frame's parent.
   //
   // See the class comment above CrossProcessFrameConnector for more
   // information.
   //
   // This will move to RenderFrameProxyHost when that class is created.
   CrossProcessFrameConnector* cross_process_frame_connector_;
 
   // Reference to the whole frame tree that this RenderFrameHost belongs too.

[Charlie Reis, 2014/01/06 18:13:35]

nit: too -> to

[nasko, 2014/01/06 18:47:03]

Done.

   // Allows this RenderFrameHost to add and remove nodes in response to
   // messages from the renderer requesting DOM manipulation.
   FrameTree* frame_tree_;
 
   // The FrameTreeNode which this RenderFrameHostImpl is hosted in.
   FrameTreeNode* frame_tree_node_;
 
   int routing_id_;
   bool is_swapped_out_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_