Rename frame classes

components/html_viewer/html_frame.h

 // Copyright 2015 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 COMPONENTS_HTML_VIEWER_HTML_FRAME_H_
 #define COMPONENTS_HTML_VIEWER_HTML_FRAME_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/html_viewer/html_frame_tree_manager.h"
 #include "components/html_viewer/replicated_frame_state.h"
 #include "components/mus/public/cpp/view_observer.h"
-#include "components/web_view/public/interfaces/frame_tree.mojom.h"
+#include "components/web_view/public/interfaces/frame.mojom.h"
 #include "mojo/services/tracing/public/interfaces/tracing.mojom.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebRemoteFrameClient.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 #include "third_party/WebKit/public/web/WebTextInputInfo.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
 
 namespace cc_blink {
 class WebLayerImpl;
@@ skipping 22 matching lines @@
 class HTMLFrameTreeManager;
 class HTMLWidget;
 class TouchHandler;
 class WebLayerTreeViewImpl;
 
 // Frame is used to represent a single frame in the frame tree of a page. The
 // frame is either local or remote. Each Frame is associated with a single
 // HTMLFrameTreeManager and can not be moved to another HTMLFrameTreeManager.
 // Local frames have a mus::View, remote frames do not.
 //
-// HTMLFrame serves as the FrameTreeClient. It implements it by forwarding
-// the calls to HTMLFrameTreeManager so that HTMLFrameTreeManager can update
-// the frame tree as appropriate.
+// HTMLFrame serves as the FrameClient. It implements it by forwarding the
+// calls to HTMLFrameTreeManager so that HTMLFrameTreeManager can update the
+// frame tree as appropriate.
 //
 // Local frames may share the connection (and client implementation) with an
 // ancestor. This happens when a child frame is created. Once a navigate
 // happens the frame is swapped to a remote frame.
 //
 // Remote frames may become local again if the embed happens in the same
 // process. See HTMLFrameTreeManager for details.
 class HTMLFrame : public blink::WebFrameClient,
                   public blink::WebRemoteFrameClient,
-                  public web_view::FrameTreeClient,
+                  public web_view::mojom::FrameClient,
                   public mus::ViewObserver {
  public:
   struct CreateParams {
     CreateParams(
         HTMLFrameTreeManager* manager,
         HTMLFrame* parent,
         uint32_t id,
         mus::View* view,
         const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties,
         HTMLFrameDelegate* delegate)
@@ skipping 107 matching lines @@
       const blink::WebHistoryItem& item,
       blink::WebHistoryCommitType commit_type);
   virtual void didReceiveTitle(blink::WebLocalFrame* frame,
                                const blink::WebString& title,
                                blink::WebTextDirection direction);
 
  private:
   friend class HTMLFrameTreeManager;
 
   // Binds this frame to the specified server. |this| serves as the
-  // FrameTreeClient for the server.
-  void Bind(web_view::FrameTreeServerPtr frame_tree_server,
-            mojo::InterfaceRequest<web_view::FrameTreeClient>
-                frame_tree_client_request);
+  // FrameClient for the server.
+  void Bind(web_view::mojom::FramePtr frame,
+            mojo::InterfaceRequest<web_view::mojom::FrameClient>
+                frame_client_request);
 
   // Sets the appropriate value from the client property. |name| identifies
   // the property and |new_data| the new value.
   void SetValueFromClientProperty(const std::string& name,
                                   mojo::Array<uint8_t> new_data);
 
   // The local root is the first ancestor (starting at this) that has its own
   // delegate.
   HTMLFrame* GetFirstAncestorWithDelegate();
 
   // Returns the ApplicationImpl from the first ancestor with a delegate.
   mojo::ApplicationImpl* GetApp();
 
-  // Gets the FrameTreeServer to use for this frame.
-  web_view::FrameTreeServer* GetFrameTreeServer();
+  // Gets the server Frame to use for this frame.
+  web_view::mojom::Frame* GetServerFrame();
 
   void SetView(mus::View* view);
 
   // Creates the appropriate WebWidget implementation for the Frame.
   void CreateRootWebWidget();
   void CreateLocalRootWebWidget(blink::WebLocalFrame* local_frame);
 
   void UpdateFocus();
 
   // Swaps this frame from a local frame to remote frame. |request| is the url
@@ skipping 21 matching lines @@
 
   // mus::ViewObserver methods:
   void OnViewBoundsChanged(mus::View* view,
                            const mojo::Rect& old_bounds,
                            const mojo::Rect& new_bounds) override;
   void OnViewDestroyed(mus::View* view) override;
   void OnViewInputEvent(mus::View* view, const mojo::EventPtr& event) override;
   void OnViewFocusChanged(mus::View* gained_focus,
                           mus::View* lost_focus) override;
 
-  // web_view::FrameTreeClient:
-  void OnConnect(web_view::FrameTreeServerPtr server,
+  // web_view::mojom::FrameClient:
+  void OnConnect(web_view::mojom::FramePtr server,
                  uint32_t change_id,
                  uint32_t view_id,
-                 web_view::ViewConnectType view_connect_type,
-                 mojo::Array<web_view::FrameDataPtr> frame_data,
+                 web_view::mojom::ViewConnectType view_connect_type,
+                 mojo::Array<web_view::mojom::FrameDataPtr> frame_data,
                  const OnConnectCallback& callback) override;
   void OnFrameAdded(uint32_t change_id,
-                    web_view::FrameDataPtr frame_data) override;
+                    web_view::mojom::FrameDataPtr frame_data) override;
   void OnFrameRemoved(uint32_t change_id, uint32_t frame_id) override;
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_value) override;
   void OnPostMessageEvent(
       uint32_t source_frame_id,
       uint32_t target_frame_id,
-      web_view::HTMLMessageEventPtr serialized_event) override;
+      web_view::mojom::HTMLMessageEventPtr serialized_event) override;
   void OnWillNavigate() override;
   void OnFrameLoadingStateChanged(uint32_t frame_id, bool loading) override;
   void OnDispatchFrameLoadEvent(uint32_t frame_id) override;
 
   // blink::WebRemoteFrameClient:
   virtual void frameDetached(blink::WebRemoteFrameClient::DetachType type);
   virtual void postMessageEvent(blink::WebLocalFrame* source_web_frame,
                                 blink::WebRemoteFrame* target_web_frame,
                                 blink::WebSecurityOrigin target_origin,
                                 blink::WebDOMMessageEvent event);
@@ skipping 14 matching lines @@
   const uint32_t id_;
   std::vector<HTMLFrame*> children_;
   blink::WebFrame* web_frame_;
   scoped_ptr<HTMLWidget> html_widget_;
   scoped_ptr<GeolocationClientImpl> geolocation_client_impl_;
   scoped_ptr<TouchHandler> touch_handler_;
 
   scoped_ptr<cc_blink::WebLayerImpl> web_layer_;
 
   HTMLFrameDelegate* delegate_;
-  scoped_ptr<mojo::Binding<web_view::FrameTreeClient>>
-      frame_tree_client_binding_;
-  web_view::FrameTreeServerPtr server_;
+  scoped_ptr<mojo::Binding<web_view::mojom::FrameClient>> frame_client_binding_;
+  web_view::mojom::FramePtr server_;
 
   ReplicatedFrameState state_;
 
   // If this frame is the result of creating a local frame
   // (createChildFrame()), then |owned_view_| is the View initially created
   // for the frame. While the frame is local |owned_view_| is the same as
   // |view_|. If this frame becomes remote |view_| is set to null and
   // |owned_view_| remains as the View initially created for the frame.
   //
   // This is done to ensure the View isn't prematurely deleted (it must exist
   // as long as the frame is valid). If the View was deleted as soon as the
   // frame was swapped to remote then the process rendering to the view would
   // be severed.
   scoped_ptr<mus::ScopedViewPtr> owned_view_;
 
   // This object is only valid in the context of performance tests.
   tracing::StartupPerformanceDataCollectorPtr
       startup_performance_data_collector_;
 
   scoped_ptr<DevToolsAgentImpl> devtools_agent_;
 
   base::WeakPtrFactory<HTMLFrame> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HTMLFrame);
 };
 
 }  // namespace html_viewer
 
 #endif  // COMPONENTS_HTML_VIEWER_HTML_FRAME_H_