Mandoline webview: 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 10 matching lines @@
 namespace web_view {
 
 class FrameTest;
 class FrameTree;
 class FrameUserData;
 
 namespace mojom {
 class FrameClient;
 }
 
-enum class ViewOwnership {
-  OWNS_VIEW,
-  DOESNT_OWN_VIEW,
+enum class WindowOwnership {
+  OWNS_WINDOW,
+  DOESNT_OWN_WINDOW,
 };
 
 // Frame represents an embedding in a frame. Frames own their children.
-// Frames automatically delete themself if the View the frame is associated
+// Frames automatically delete themself if the Window the frame is associated
 // with is deleted.
 //
-// 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()).
+// In general each Frame has a Window. When a new Frame is created by a client
+// there may be a small amount of time where the Window is not yet known
+// (separate pipes are used for the window and frame, resulting in undefined
+// message ordering). In this case the window is null and will be set once we
+// see the window (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 WindowTreeClient is not obtained and
-// Embed() is not invoked on the View. The FrameClient can detect this case by
+// existing window. Because of this a new WindowTreeClient is not obtained and
+// Embed() is not invoked on the Window. 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,
+        mus::Window* window,
         uint32_t frame_id,
         uint32_t app_id,
-        ViewOwnership view_ownership,
+        WindowOwnership window_ownership,
         mojom::FrameClient* frame_client,
         scoped_ptr<FrameUserData> user_data,
         const ClientPropertyMap& client_properties);
   ~Frame() override;
 
   void Init(Frame* parent,
             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|
+  // Walks the Window tree starting at |window| going up returning the first
+  // Frame that is associated with |window|. For example, if |window|
   // has a Frame associated with it, then that is returned. Otherwise
-  // this checks view->parent() and so on.
-  static Frame* FindFirstFrameAncestor(mus::Window* view);
+  // this checks window->parent() and so on.
+  static Frame* FindFirstFrameAncestor(mus::Window* window);
 
   FrameTree* tree() { return tree_; }
 
   Frame* parent() { return parent_; }
   const Frame* parent() const { return parent_; }
 
-  mus::Window* view() { return view_; }
-  const mus::Window* view() const { return view_; }
+  mus::Window* window() { return window_; }
+  const mus::Window* window() const { return window_; }
 
   uint32_t id() const { return id_; }
 
   uint32_t app_id() const { return app_id_; }
 
   bool loading() const { return loading_; }
 
   const ClientPropertyMap& client_properties() const {
     return client_properties_;
   }
@@ skipping 82 matching lines @@
                          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,
                     mus::mojom::WindowTreeClientPtr window_tree_client,
                     uint32 app_id,
                     base::TimeTicks navigation_start_time);
 
-  void SetView(mus::Window* view);
+  void SetWindow(mus::Window* window);
 
   // 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.
+  // as there is a Window and once OnWillNavigate() has returned. If there is
+  // no Window the navigation waits until the Window 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,
                           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,
                                    const mojo::Array<uint8_t>& value);
   void NotifyFrameLoadingStateChanged(const Frame* frame, bool loading);
   void NotifyDispatchFrameLoadEvent(const Frame* frame);
 
   // mus::WindowObserver:
   void OnTreeChanged(const TreeChangeParams& params) override;
-  void OnWindowDestroying(mus::Window* view) override;
-  void OnWindowEmbeddedAppDisconnected(mus::Window* view) override;
+  void OnWindowDestroying(mus::Window* window) override;
+  void OnWindowEmbeddedAppDisconnected(mus::Window* window) override;
 
   // mojom::Frame:
   void PostMessageEventToFrame(uint32_t target_frame_id,
                                mojom::HTMLMessageEventPtr event) override;
   void LoadingStateChanged(bool loading, double progress) override;
   void TitleChanged(const mojo::String& title) override;
   void DidCommitProvisionalLoad() override;
   void SetClientProperty(const mojo::String& name,
                          mojo::Array<uint8_t> value) override;
   void OnCreatedFrame(
       mojo::InterfaceRequest<mojom::Frame> frame_request,
       mojom::FrameClientPtr client,
       uint32_t frame_id,
       mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties) override;
   void RequestNavigate(mojom::NavigationTargetType target_type,
                        uint32_t target_frame_id,
                        mojo::URLRequestPtr request) override;
   void DidNavigateLocally(const mojo::String& url) override;
   void DispatchLoadEventToParent() override;
   void OnFindInFrameCountUpdated(int32_t request_id,
                                  int32_t count,
                                  bool final_update) override;
   void OnFindInPageSelectionUpdated(int32_t request_id,
                                     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
+  mus::Window* window_;
+  // The connection id returned from WindowManager::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.
+  // ID for the frame, which is the same as that of the window.
   const uint32_t id_;
   // ID of the app providing the FrameClient and WindowTreeClient.
   uint32_t app_id_;
   Frame* parent_;
-  ViewOwnership view_ownership_;
+  WindowOwnership window_ownership_;
   std::vector<Frame*> children_;
   scoped_ptr<FrameUserData> user_data_;
 
   mojom::FrameClient* frame_client_;
 
   bool loading_;
   double progress_;
 
   ClientPropertyMap client_properties_;
 
-  // StartNavigate() stores the request here if the view isn't available at
+  // StartNavigate() stores the request here if the window isn't available at
   // the time of StartNavigate().
   mojo::URLRequestPtr pending_navigate_;
 
   scoped_ptr<mojo::Binding<mojom::Frame>> frame_binding_;
 
   // True if waiting on callback from FrameClient::OnWillNavigate().
   bool waiting_for_on_will_navigate_ack_;
 
   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_