components/mus/public/interfaces View => Window

components/web_view/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_WEB_VIEW_FRAME_H_
 #define COMPONENTS_WEB_VIEW_FRAME_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 29 matching lines @@
 // In general each Frame has a View. When a new Frame is created by a client
 // there may be a small amount of time where the View is not yet known
 // (separate pipes are used for the view and frame, resulting in undefined
 // message ordering). In this case the view is null and will be set once we
 // see the view (OnTreeChanged()).
 //
 // Each frame has an identifier of the app providing the FrameClient
 // (|app_id|). This id is used when servicing a request to navigate the frame.
 // When navigating, if the id of the new app matches that of the existing app,
 // then it is expected that the new FrameClient will take over rendering to the
-// existing view. Because of this a new ViewTreeClient is not obtained and
+// existing view. Because of this a new WindowTreeClient is not obtained and
 // Embed() is not invoked on the View. The FrameClient can detect this case by
 // the argument |reuse_existing_view| supplied to OnConnect(). Typically the id
 // is that of content handler id, but this is left up to the FrameTreeDelegate
 // to decide.
 class Frame : public mus::WindowObserver, public mojom::Frame {
  public:
   using ClientPropertyMap = std::map<std::string, std::vector<uint8_t>>;
   using FindCallback = mojo::Callback<void(bool)>;
 
   Frame(FrameTree* tree,
         mus::Window* view,
         uint32_t frame_id,
         uint32_t app_id,
         ViewOwnership view_ownership,
         mojom::FrameClient* frame_client,
         scoped_ptr<FrameUserData> user_data,
         const ClientPropertyMap& client_properties);
   ~Frame() override;
 
   void Init(Frame* parent,
-            mojo::ViewTreeClientPtr view_tree_client,
+            mus::mojom::WindowTreeClientPtr window_tree_client,
             mojo::InterfaceRequest<mojom::Frame> frame_request,
             base::TimeTicks navigation_start_time);
 
   // Walks the View tree starting at |view| going up returning the first
   // Frame that is associated with |view|. For example, if |view|
   // has a Frame associated with it, then that is returned. Otherwise
   // this checks view->parent() and so on.
   static Frame* FindFirstFrameAncestor(mus::Window* view);
 
   FrameTree* tree() { return tree_; }
@@ skipping 70 matching lines @@
   // |data_and_binding| contains the current FrameUserDataAndBinding (if any)
   // and is destroyed after the connection responds to OnConnect().
   //
   // If |client_type| is SAME_APP we can't destroy the existing client
   // (and related data) until we get back the ack from OnConnect(). This way
   // we know the client has completed the switch. If we did not do this it
   // would be possible for the app to see it's existing Frame connection lost
   // (and assume the frame is being torn down) before the OnConnect().
   void InitClient(ClientType client_type,
                   scoped_ptr<FrameUserDataAndBinding> data_and_binding,
-                  mojo::ViewTreeClientPtr view_tree_client,
+                  mus::mojom::WindowTreeClientPtr window_tree_client,
                   mojo::InterfaceRequest<mojom::Frame> frame_request,
                   base::TimeTicks navigation_start_time);
 
   // Callback from OnConnect(). This does nothing (other than destroying
   // |data_and_binding|). See InitClient() for details as to why destruction of
   // |data_and_binding| happens after OnConnect().
   static void OnConnectAck(
       scoped_ptr<FrameUserDataAndBinding> data_and_binding);
 
   // Callback from OnEmbed().
   void OnEmbedAck(bool success, mus::ConnectionSpecificId connection_id);
 
   // Callback from Frame::OnWillNavigate(). Completes navigation.
   void OnWillNavigateAck(mojom::FrameClient* frame_client,
                          scoped_ptr<FrameUserData> user_data,
-                         mojo::ViewTreeClientPtr view_tree_client,
+                         mus::mojom::WindowTreeClientPtr window_tree_client,
                          uint32 app_id,
                          base::TimeTicks navigation_start_time);
 
   // Completes a navigation request; swapping the existing FrameClient to the
   // supplied arguments.
   void ChangeClient(mojom::FrameClient* frame_client,
                     scoped_ptr<FrameUserData> user_data,
-                    mojo::ViewTreeClientPtr view_tree_client,
+                    mus::mojom::WindowTreeClientPtr window_tree_client,
                     uint32 app_id,
                     base::TimeTicks navigation_start_time);
 
   void SetView(mus::Window* view);
 
   // Adds this to |frames| and recurses through the children calling the
   // same function.
   void BuildFrameTree(std::vector<const Frame*>* frames) const;
 
   void Add(Frame* node);
   void Remove(Frame* node);
 
   // Starts a new navigation to |request|. The navigation proceeds as long
   // as there is a View and once OnWillNavigate() has returned. If there is
   // no View the navigation waits until the View is available.
   void StartNavigate(mojo::URLRequestPtr request);
   void OnCanNavigateFrame(const GURL& url,
                           base::TimeTicks navigation_start_time,
                           uint32_t app_id,
                           mojom::FrameClient* frame_client,
                           scoped_ptr<FrameUserData> user_data,
-                          mojo::ViewTreeClientPtr view_tree_client);
+                          mus::mojom::WindowTreeClientPtr window_tree_client);
 
   // Notifies the client and all descendants as appropriate.
   void NotifyAdded(const Frame* source,
                    const Frame* added_node,
                    uint32_t change_id);
   void NotifyRemoved(const Frame* source,
                      const Frame* removed_node,
                      uint32_t change_id);
   void NotifyClientPropertyChanged(const Frame* source,
                                    const mojo::String& name,
@@ skipping 31 matching lines @@
                                     int32_t active_match_ordinal) override;
 
   FrameTree* const tree_;
   // WARNING: this may be null. See class description for details.
   mus::Window* view_;
   // The connection id returned from ViewManager::Embed(). Frames created by
   // way of OnCreatedFrame() inherit the id from the parent.
   mus::ConnectionSpecificId embedded_connection_id_;
   // ID for the frame, which is the same as that of the view.
   const uint32_t id_;
-  // ID of the app providing the FrameClient and ViewTreeClient.
+  // ID of the app providing the FrameClient and WindowTreeClient.
   uint32_t app_id_;
   Frame* parent_;
   ViewOwnership view_ownership_;
   std::vector<Frame*> children_;
   scoped_ptr<FrameUserData> user_data_;
 
   mojom::FrameClient* frame_client_;
 
   bool loading_;
   double progress_;
@@ skipping 12 matching lines @@
   base::WeakPtrFactory<Frame> embed_weak_ptr_factory_;
 
   base::WeakPtrFactory<Frame> navigate_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Frame);
 };
 
 }  // namespace web_view
 
 #endif  // COMPONENTS_WEB_VIEW_FRAME_H_