Mandoline UI Process: Update namespaces and file names

components/html_viewer/html_frame.cc

 // 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.
 
 #include "components/html_viewer/html_frame.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 53 matching lines @@
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 #include "url/url_constants.h"
 
 using mojo::AxProvider;
 using mojo::Rect;
 using mojo::ServiceProviderPtr;
 using mojo::URLResponsePtr;
-using mojo::View;
+using mus::View;
 using web_view::HTMLMessageEvent;
 using web_view::HTMLMessageEventPtr;
 
 namespace html_viewer {
 namespace {
 
 const size_t kMaxTitleChars = 4 * 1024;
 
 web_view::NavigationTargetType WebNavigationPolicyToNavigationTarget(
     blink::WebNavigationPolicy policy) {
@@ skipping 183 matching lines @@
   }
   parent_ = nullptr;
 
   frame_tree_manager_->OnFrameDestroyed(this);
 
   if (delegate_)
     delegate_->OnFrameDestroyed();
 
   if (view_) {
     view_->RemoveObserver(this);
-    mojo::ScopedViewPtr::DeleteViewOrViewManager(view_);
+    mus::ScopedViewPtr::DeleteViewOrViewManager(view_);
   }
 }
 
 blink::WebMediaPlayer* HTMLFrame::createMediaPlayer(
     blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     blink::WebContentDecryptionModule* initial_cdm) {
   return global_state()->media_factory()->CreateMediaPlayer(
       frame, url, client, encrypted_client, initial_cdm,
       GetLocalRootApp()->shell());
 }
 
 blink::WebFrame* HTMLFrame::createChildFrame(
     blink::WebLocalFrame* parent,
     blink::WebTreeScopeType scope,
     const blink::WebString& frame_name,
     blink::WebSandboxFlags sandbox_flags) {
   DCHECK(IsLocal());  // Can't create children of remote frames.
   DCHECK_EQ(parent, web_frame_);
   DCHECK(view_);  // If we're local we have to have a view.
   // Create the view that will house the frame now. We embed once we know the
   // url (see decidePolicyForNavigation()).
-  mojo::View* child_view = view_->connection()->CreateView();
+  mus::View* child_view = view_->connection()->CreateView();
   ReplicatedFrameState child_state;
   child_state.name = frame_name;
   child_state.tree_scope = scope;
   child_state.sandbox_flags = sandbox_flags;
   mojo::Map<mojo::String, mojo::Array<uint8_t>> client_properties;
   client_properties.mark_non_null();
   ClientPropertiesFromReplicatedFrameState(child_state, &client_properties);
 
   child_view->SetVisible(true);
   view_->AddChild(child_view);
 
   GetLocalRoot()->server_->OnCreatedFrame(id_, child_view->id(),
                                           client_properties.Pass());
 
   HTMLFrame::CreateParams params(frame_tree_manager_, this, child_view->id(),
                                  child_view, client_properties, nullptr);
   params.allow_local_shared_frame = true;
   HTMLFrame* child_frame =
       GetLocalRoot()->delegate_->GetHTMLFactory()->CreateHTMLFrame(&params);
-  child_frame->owned_view_.reset(new mojo::ScopedViewPtr(child_view));
+  child_frame->owned_view_.reset(new mus::ScopedViewPtr(child_view));
   return child_frame->web_frame_;
 }
 
 void HTMLFrame::frameDetached(blink::WebFrame* web_frame,
                               blink::WebFrameClient::DetachType type) {
   if (type == blink::WebFrameClient::DetachType::Swap) {
     web_frame->close();
     return;
   }
 
@@ skipping 153 matching lines @@
   // Prefer the local root.
   HTMLFrame* local_root = GetLocalRoot();
   if (local_root)
     return local_root->server_.get();
 
   // No local root. This means we're a remote frame with no local frame
   // ancestors. Use the local frame from the FrameTreeServer.
   return frame_tree_manager_->local_root_->server_.get();
 }
 
-void HTMLFrame::SetView(mojo::View* view) {
+void HTMLFrame::SetView(mus::View* view) {
   if (view_)
     view_->RemoveObserver(this);
   view_ = view;
   if (view_)
     view_->AddObserver(this);
 }
 
 void HTMLFrame::CreateRootWebWidget() {
   DCHECK(!html_widget_);
   if (view_) {
@@ skipping 46 matching lines @@
   remote_frame->setReplicatedOrigin(state_.origin);
   remote_frame->setReplicatedSandboxFlags(state_.sandbox_flags);
   web_frame_ = remote_frame;
   SetView(nullptr);
   if (delegate)
     delegate->OnFrameSwappedToRemote();
 }
 
 void HTMLFrame::SwapToLocal(
     HTMLFrameDelegate* delegate,
-    mojo::View* view,
+    mus::View* view,
     const mojo::Map<mojo::String, mojo::Array<uint8_t>>& properties) {
   CHECK(!IsLocal());
   // It doesn't make sense for the root to swap to local.
   CHECK(parent_);
   delegate_ = delegate;
   SetView(view);
   SetReplicatedFrameStateFromClientProperties(properties, &state_);
   blink::WebLocalFrame* local_web_frame =
       blink::WebLocalFrame::create(state_.tree_scope, this);
   local_web_frame->initializeToReplaceRemoteFrame(
@@ skipping 80 matching lines @@
 
   if (!web_widget)
     return;
 
   scoped_ptr<blink::WebInputEvent> web_event =
       event.To<scoped_ptr<blink::WebInputEvent>>();
   if (web_event)
     web_widget->handleInputEvent(*web_event);
 }
 
-void HTMLFrame::OnViewFocusChanged(mojo::View* gained_focus,
-                                   mojo::View* lost_focus) {
+void HTMLFrame::OnViewFocusChanged(mus::View* gained_focus,
+                                   mus::View* lost_focus) {
   UpdateFocus();
 }
 
 void HTMLFrame::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) {
   // OnConnect() is only sent once, and has been received (by
@@ skipping 129 matching lines @@
 
 void HTMLFrame::reload(bool ignore_cache, bool is_client_redirect) {
   NOTIMPLEMENTED();
 }
 
 void HTMLFrame::forwardInputEvent(const blink::WebInputEvent* event) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace mojo