Revert of Mandoline UI Process: Update namespaces and file names

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 31 matching lines @@
 //
 // Each frame has an identifier of the app providing the FrameTreeClient
 // (|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 FrameTreeClient will take over rendering to
 // the existing view. Because of this a new ViewTreeClient is not obtained and
 // Embed() is not invoked on the View. The FrameTreeClient 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::ViewObserver, public FrameTreeServer {
+class Frame : public mojo::ViewObserver, public FrameTreeServer {
  public:
   using ClientPropertyMap = std::map<std::string, std::vector<uint8_t>>;
 
   Frame(FrameTree* tree,
-        mus::View* view,
+        mojo::View* view,
         uint32_t frame_id,
         uint32_t app_id,
         ViewOwnership view_ownership,
         FrameTreeClient* frame_tree_client,
         scoped_ptr<FrameUserData> user_data,
         const ClientPropertyMap& client_properties);
   ~Frame() override;
 
   void Init(Frame* parent, mojo::ViewTreeClientPtr view_tree_client);
 
   // 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::View* view);
+  static Frame* FindFirstFrameAncestor(mojo::View* view);
 
   FrameTree* tree() { return tree_; }
 
   Frame* parent() { return parent_; }
   const Frame* parent() const { return parent_; }
 
-  mus::View* view() { return view_; }
-  const mus::View* view() const { return view_; }
+  mojo::View* view() { return view_; }
+  const mojo::View* view() const { return view_; }
 
   uint32_t id() const { return id_; }
 
   uint32_t app_id() const { return app_id_; }
 
   const ClientPropertyMap& client_properties() const {
     return client_properties_;
   }
 
   // Finds the descendant with the specified id.
@@ skipping 39 matching lines @@
                   scoped_ptr<FrameTreeServerBinding> frame_tree_server_binding,
                   mojo::ViewTreeClientPtr view_tree_client);
 
   // Callback from OnConnect(). This does nothing (other than destroying
   // |frame_tree_server_binding|). See InitClient() for details as to why
   // destruction of |frame_tree_server_binding| happens after OnConnect().
   static void OnConnectAck(
       scoped_ptr<FrameTreeServerBinding> frame_tree_server_binding);
 
   // Callback from OnEmbed().
-  void OnEmbedAck(bool success, mus::ConnectionSpecificId connection_id);
+  void OnEmbedAck(bool success, mojo::ConnectionSpecificId connection_id);
 
   // Completes a navigation request; swapping the existing FrameTreeClient to
   // the supplied arguments.
   void ChangeClient(FrameTreeClient* frame_tree_client,
                     scoped_ptr<FrameUserData> user_data,
                     mojo::ViewTreeClientPtr view_tree_client,
                     uint32 app_id);
 
-  void SetView(mus::View* view);
+  void SetView(mojo::View* view);
 
   // Returns the first ancestor (starting at |this|) that has a
   // FrameTreeClient.
   Frame* GetAncestorWithFrameTreeClient();
 
   // 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);
@@ skipping 25 matching lines @@
   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);
 
-  // mus::ViewObserver:
+  // mojo::ViewObserver:
   void OnTreeChanged(const TreeChangeParams& params) override;
-  void OnViewDestroying(mus::View* view) override;
-  void OnViewEmbeddedAppDisconnected(mus::View* view) override;
+  void OnViewDestroying(mojo::View* view) override;
+  void OnViewEmbeddedAppDisconnected(mojo::View* view) override;
 
   // FrameTreeServer:
   void PostMessageEventToFrame(uint32_t source_frame_id,
                                uint32_t target_frame_id,
                                HTMLMessageEventPtr event) override;
   void LoadingStarted(uint32_t frame_id) override;
   void LoadingStopped(uint32_t frame_id) override;
   void ProgressChanged(uint32_t frame_id, double progress) override;
   void TitleChanged(uint32_t frame_id, const mojo::String& title) override;
   void SetClientProperty(uint32_t frame_id,
                          const mojo::String& name,
                          mojo::Array<uint8_t> value) override;
   void OnCreatedFrame(
       uint32_t parent_id,
       uint32_t frame_id,
       mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties) override;
   void RequestNavigate(NavigationTargetType target_type,
                        uint32_t target_frame_id,
                        mojo::URLRequestPtr request) override;
   void DidNavigateLocally(uint32_t frame_id, const mojo::String& url) override;
 
   FrameTree* const tree_;
   // WARNING: this may be null. See class description for details.
-  mus::View* view_;
+  mojo::View* 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_;
+  mojo::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 FrameTreeClient and ViewTreeClient.
   uint32_t app_id_;
   Frame* parent_;
   ViewOwnership view_ownership_;
   std::vector<Frame*> children_;
   scoped_ptr<FrameUserData> user_data_;
 
   // WARNING: this may be null. See class description for details.
@@ skipping 13 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_