Mandoline UI Process: Update namespaces and file names

components/html_viewer/html_document.cc

 // Copyright 2014 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_document.h"
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 13 matching lines @@
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/interfaces/shell.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/mojo/src/mojo/public/cpp/system/data_pipe.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size.h"
 
 using mojo::AxProvider;
-using mojo::View;
+using mus::View;
 
 namespace html_viewer {
 namespace {
 
 const char kEnableTestInterface[] = "enable-html-viewer-test-interface";
 
 bool IsTestInterfaceEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       kEnableTestInterface);
 }
 
 }  // namespace
 
 // A ViewTreeDelegate implementation that delegates to a (swappable) delegate.
 // This is used when one HTMLDocument takes over for another delegate
 // (OnSwap()).
-class ViewTreeDelegateImpl : public mojo::ViewTreeDelegate {
+class ViewTreeDelegateImpl : public mus::ViewTreeDelegate {
  public:
-  explicit ViewTreeDelegateImpl(mojo::ViewTreeDelegate* delegate)
+  explicit ViewTreeDelegateImpl(mus::ViewTreeDelegate* delegate)
       : delegate_(delegate) {}
   ~ViewTreeDelegateImpl() override {}
 
-  void set_delegate(mojo::ViewTreeDelegate* delegate) { delegate_ = delegate; }
+  void set_delegate(mus::ViewTreeDelegate* delegate) { delegate_ = delegate; }
 
  private:
   // ViewTreeDelegate:
-  void OnEmbed(mojo::View* root) override { delegate_->OnEmbed(root); }
+  void OnEmbed(mus::View* root) override { delegate_->OnEmbed(root); }
   void OnUnembed() override { delegate_->OnUnembed(); }
-  void OnConnectionLost(mojo::ViewTreeConnection* connection) override {
+  void OnConnectionLost(mus::ViewTreeConnection* connection) override {
     delegate_->OnConnectionLost(connection);
   }
 
-  mojo::ViewTreeDelegate* delegate_;
+  mus::ViewTreeDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewTreeDelegateImpl);
 };
 
 HTMLDocument::BeforeLoadCache::BeforeLoadCache() {}
 
 HTMLDocument::BeforeLoadCache::~BeforeLoadCache() {
   STLDeleteElements(&ax_provider_requests);
   STLDeleteElements(&test_interface_requests);
 }
@@ skipping 32 matching lines @@
   connection->AddService<devtools_service::DevToolsAgent>(this);
   if (IsTestInterfaceEnabled())
     connection->AddService<TestHTMLViewer>(this);
 
   resource_waiter_.reset(
       new DocumentResourceWaiter(global_state_, response.Pass(), this));
 }
 
 void HTMLDocument::Destroy() {
   if (resource_waiter_) {
-    mojo::View* root = resource_waiter_->root();
+    mus::View* root = resource_waiter_->root();
     if (root) {
       resource_waiter_.reset();
       delete root->connection();
     } else {
       delete this;
     }
   } else if (frame_) {
     // Closing the frame ends up destroying the ViewManager, which triggers
     // deleting this (OnConnectionLost()).
     frame_->Close();
@@ skipping 11 matching lines @@
 HTMLDocument::~HTMLDocument() {
   delete_callback_.Run(this);
 
   STLDeleteElements(&ax_providers_);
 }
 
 void HTMLDocument::Load() {
   DCHECK(resource_waiter_ && resource_waiter_->is_ready());
 
   // Note: |view| is null if we're taking over for an existing frame.
-  mojo::View* view = resource_waiter_->root();
+  mus::View* view = resource_waiter_->root();
   if (view) {
     global_state_->InitIfNecessary(
         view->viewport_metrics().size_in_pixels.To<gfx::Size>(),
         view->viewport_metrics().device_pixel_ratio);
   }
 
   scoped_ptr<WebURLRequestExtraData> extra_data(new WebURLRequestExtraData);
   extra_data->synthetic_response =
       resource_waiter_->ReleaseURLResponse().Pass();
 
@@ skipping 30 matching lines @@
   if (!before_load_cache_.get())
     before_load_cache_.reset(new BeforeLoadCache);
   return before_load_cache_.get();
 }
 
 void HTMLDocument::OnEmbed(View* root) {
   transferable_state_.root = root;
   resource_waiter_->SetRoot(root);
 }
 
-void HTMLDocument::OnConnectionLost(mojo::ViewTreeConnection* connection) {
+void HTMLDocument::OnConnectionLost(mus::ViewTreeConnection* connection) {
   delete this;
 }
 
 void HTMLDocument::OnFrameDidFinishLoad() {
   did_finish_local_frame_load_ = true;
   scoped_ptr<BeforeLoadCache> before_load_cache = before_load_cache_.Pass();
   if (!before_load_cache)
     return;
 
   // Bind any pending AxProvider and TestHTMLViewer interface requests.
@@ skipping 95 matching lines @@
   }
 }
 
 void HTMLDocument::Create(
     mojo::ApplicationConnection* connection,
     mojo::InterfaceRequest<mojo::ViewTreeClient> request) {
   DCHECK(!transferable_state_.view_tree_delegate_impl);
   transferable_state_.view_tree_delegate_impl.reset(
       new ViewTreeDelegateImpl(this));
   transferable_state_.owns_view_tree_connection = true;
-  mojo::ViewTreeConnection::Create(
+  mus::ViewTreeConnection::Create(
       transferable_state_.view_tree_delegate_impl.get(), request.Pass());
 }
 
 }  // namespace html_viewer