Revert of Mandoline UI Process: Update namespaces and file names

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"
@@ skipping 15 matching lines @@
 }
 
 namespace blink {
 class WebFrame;
 class WebWidget;
 }
 
 namespace mojo {
 class ApplicationImpl;
 class Rect;
-}
-
-namespace mus {
 class ScopedViewPtr;
 class View;
 }
 
 namespace html_viewer {
 
 class DevToolsAgentImpl;
 class GeolocationClientImpl;
 class HTMLFrameDelegate;
 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.
+// Local frames have a mojo::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.
 //
 // 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 mus::ViewObserver {
+                  public mojo::ViewObserver {
  public:
   struct CreateParams {
     CreateParams(
         HTMLFrameTreeManager* manager,
         HTMLFrame* parent,
         uint32_t id,
-        mus::View* view,
+        mojo::View* view,
         const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties,
         HTMLFrameDelegate* delegate)
         : manager(manager),
           parent(parent),
           id(id),
           view(view),
           properties(properties),
           delegate(delegate),
           allow_local_shared_frame(false) {}
     ~CreateParams() {}
 
     HTMLFrameTreeManager* manager;
     HTMLFrame* parent;
     uint32_t id;
-    mus::View* view;
+    mojo::View* view;
     const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties;
     HTMLFrameDelegate* delegate;
 
    private:
     friend class HTMLFrame;
 
     // TODO(sky): nuke.
     bool allow_local_shared_frame;
   };
 
@@ skipping 17 matching lines @@
 
   // Returns the WebFrame for this Frame. This is either a WebLocalFrame or
   // WebRemoteFrame.
   blink::WebFrame* web_frame() { return web_frame_; }
 
   // Returns the WebView for this frame, or null if there isn't one. The root
   // has a WebView, the children WebFrameWidgets.
   blink::WebView* web_view();
   blink::WebWidget* GetWebWidget();
 
-  // The mus::View this frame renders to. This is non-null for the local frame
+  // The mojo::View this frame renders to. This is non-null for the local frame
   // the frame tree was created with as well as non-null for any frames created
   // locally.
-  mus::View* view() { return view_; }
+  mojo::View* view() { return view_; }
 
   HTMLFrameTreeManager* frame_tree_manager() { return frame_tree_manager_; }
 
   // Returns null if the browser side didn't request to setup an agent in this
   // frame.
   DevToolsAgentImpl* devtools_agent() { return devtools_agent_.get(); }
 
   // Returns true if the Frame is local, false if remote.
   bool IsLocal() const;
 
@@ skipping 61 matching lines @@
   // The local root is the first ancestor (starting at this) that has its own
   // connection.
   HTMLFrame* GetLocalRoot();
 
   // Returns the ApplicationImpl from the local root's delegate.
   mojo::ApplicationImpl* GetLocalRootApp();
 
   // Gets the FrameTreeServer to use for this frame.
   web_view::FrameTreeServer* GetFrameTreeServer();
 
-  void SetView(mus::View* view);
+  void SetView(mojo::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
   // to load in the frame.
   void SwapToRemote();
 
   // Swaps this frame from a remote frame to a local frame.
   void SwapToLocal(
       HTMLFrameDelegate* delegate,
-      mus::View* view,
+      mojo::View* view,
       const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties);
 
   // Invoked when changing the delegate. This informs the new delegate to take
   // over. This is used when a different connection is going to take over
   // responsibility for the frame.
   void SwapDelegate(HTMLFrameDelegate* delegate);
 
   GlobalState* global_state() { return frame_tree_manager_->global_state(); }
 
   // Returns the Frame associated with the specified WebFrame.
   HTMLFrame* FindFrameWithWebFrame(blink::WebFrame* web_frame);
 
   // The various frameDetached() implementations call into this.
   void FrameDetachedImpl(blink::WebFrame* web_frame);
 
-  // mus::ViewObserver methods:
-  void OnViewBoundsChanged(mus::View* view,
+  // mojo::ViewObserver methods:
+  void OnViewBoundsChanged(mojo::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;
+  void OnViewDestroyed(mojo::View* view) override;
+  void OnViewInputEvent(mojo::View* view, const mojo::EventPtr& event) override;
+  void OnViewFocusChanged(mojo::View* gained_focus,
+                          mojo::View* lost_focus) override;
 
   // web_view::FrameTreeClient:
   void OnConnect(web_view::FrameTreeServerPtr server,
                  uint32_t change_id,
                  uint32_t view_id,
                  web_view::ViewConnectType view_connect_type,
                  mojo::Array<web_view::FrameDataPtr> frame_data,
                  const OnConnectCallback& callback) override;
   void OnFrameAdded(uint32_t change_id,
                     web_view::FrameDataPtr frame_data) override;
@@ skipping 17 matching lines @@
                                     float scale_factor);
   virtual void navigate(const blink::WebURLRequest& request,
                         bool should_replace_current_entry);
   virtual void reload(bool ignore_cache, bool is_client_redirect);
   virtual void forwardInputEvent(const blink::WebInputEvent* event);
 
   HTMLFrameTreeManager* frame_tree_manager_;
   HTMLFrame* parent_;
   // |view_| is non-null for local frames or remote frames that were once
   // local.
-  mus::View* view_;
+  mojo::View* view_;
   // The id for this frame. If there is a view, this is the same id as the
   // view has.
   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_;
 
   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_;
+  scoped_ptr<mojo::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_