Mandoline UI Process: Update namespaces and file names

components/pdf_viewer/pdf_viewer.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/mus/public/cpp/types.h"
 #include "components/mus/public/cpp/view.h"
@@ skipping 40 matching lines @@
 
 void LostContext(void*) {
   DCHECK(false);
 }
 
 void OnGotContentHandlerID(uint32_t content_handler_id) {}
 
 // BitmapUploader is useful if you want to draw a bitmap or color in a View.
 class BitmapUploader : public mojo::SurfaceClient {
  public:
-  explicit BitmapUploader(mojo::View* view)
+  explicit BitmapUploader(mus::View* view)
       : view_(view),
         color_(g_transparent_color),
         width_(0),
         height_(0),
         format_(BGRA),
         next_resource_id_(1u),
         id_namespace_(0u),
         local_id_(0u),
-        returner_binding_(this) {
-  }
+        returner_binding_(this) {}
   ~BitmapUploader() override {
     MojoGLES2DestroyContext(gles2_context_);
   }
 
   void Init(mojo::Shell* shell) {
     surface_ = view_->RequestSurface();
     surface_->BindToThread();
 
     mojo::ServiceProviderPtr gpu_service_provider;
     mojo::URLRequestPtr request2(mojo::URLRequest::New());
@@ skipping 200 matching lines @@
       mojo::ReturnedResourcePtr resource = resources[i].Pass();
       DCHECK_EQ(1, resource->count);
       glWaitSyncPointCHROMIUM(resource->sync_point);
       uint32_t texture_id = resource_to_texture_id_map_[resource->id];
       DCHECK_NE(0u, texture_id);
       resource_to_texture_id_map_.erase(resource->id);
       glDeleteTextures(1, &texture_id);
     }
   }
 
-  mojo::View* view_;
+  mus::View* view_;
   mojo::GpuPtr gpu_service_;
-  scoped_ptr<mojo::ViewSurface> surface_;
+  scoped_ptr<mus::ViewSurface> surface_;
   MojoGLES2Context gles2_context_;
 
   mojo::Size size_;
   uint32_t color_;
   int width_;
   int height_;
   Format format_;
   scoped_ptr<std::vector<unsigned char>> bitmap_;
   uint32_t next_resource_id_;
   uint32_t id_namespace_;
   uint32_t local_id_;
   base::hash_map<uint32_t, uint32_t> resource_to_texture_id_map_;
   mojo::Binding<mojo::SurfaceClient> returner_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(BitmapUploader);
 };
 
 class EmbedderData {
  public:
-  EmbedderData(mojo::Shell* shell, mojo::View* root) : bitmap_uploader_(root) {
+  EmbedderData(mojo::Shell* shell, mus::View* root) : bitmap_uploader_(root) {
     bitmap_uploader_.Init(shell);
     bitmap_uploader_.SetColor(g_background_color);
   }
 
   BitmapUploader& bitmap_uploader() { return bitmap_uploader_; }
 
  private:
   BitmapUploader bitmap_uploader_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedderData);
 };
 
 class PDFView : public mojo::ApplicationDelegate,
-                public mojo::ViewTreeDelegate,
-                public mojo::ViewObserver,
+                public mus::ViewTreeDelegate,
+                public mus::ViewObserver,
                 public mojo::InterfaceFactory<mojo::ViewTreeClient> {
  public:
   PDFView(mojo::InterfaceRequest<mojo::Application> request,
           mojo::URLResponsePtr response)
       : app_(this, request.Pass(), base::Bind(&PDFView::OnTerminate,
                                               base::Unretained(this))),
         current_page_(0), page_count_(0), doc_(nullptr) {
     FetchPDF(response.Pass());
   }
 
   ~PDFView() override {
     if (doc_)
       FPDF_CloseDocument(doc_);
     for (auto& roots : embedder_for_roots_) {
       roots.first->RemoveObserver(this);
       delete roots.second;
     }
   }
 
  private:
   // Overridden from ApplicationDelegate:
   bool ConfigureIncomingConnection(
       mojo::ApplicationConnection* connection) override {
     connection->AddService<mojo::ViewTreeClient>(this);
     return true;
   }
 
   // Overridden from ViewTreeDelegate:
-  void OnEmbed(mojo::View* root) override {
+  void OnEmbed(mus::View* root) override {
     DCHECK(embedder_for_roots_.find(root) == embedder_for_roots_.end());
     root->AddObserver(this);
     EmbedderData* embedder_data = new EmbedderData(app_.shell(), root);
     embedder_for_roots_[root] = embedder_data;
     DrawBitmap(embedder_data);
   }
 
-  void OnConnectionLost(mojo::ViewTreeConnection* connection) override {}
+  void OnConnectionLost(mus::ViewTreeConnection* connection) override {}
 
   // Overridden from ViewObserver:
-  void OnViewBoundsChanged(mojo::View* view,
+  void OnViewBoundsChanged(mus::View* view,
                            const mojo::Rect& old_bounds,
                            const mojo::Rect& new_bounds) override {
     DCHECK(embedder_for_roots_.find(view) != embedder_for_roots_.end());
     DrawBitmap(embedder_for_roots_[view]);
   }
 
-  void OnViewInputEvent(mojo::View* view,
-                        const mojo::EventPtr& event) override {
+  void OnViewInputEvent(mus::View* view, const mojo::EventPtr& event) override {
     DCHECK(embedder_for_roots_.find(view) != embedder_for_roots_.end());
     if (event->key_data &&
         (event->action != mojo::EVENT_TYPE_KEY_PRESSED ||
          event->key_data->is_char)) {
       return;
     }
 
     if ((event->key_data &&
          event->key_data->windows_key_code == mojo::KEYBOARD_CODE_DOWN) ||
         (event->pointer_data && event->pointer_data->vertical_wheel < 0)) {
       if (current_page_ < (page_count_ - 1)) {
         current_page_++;
         DrawBitmap(embedder_for_roots_[view]);
       }
     } else if ((event->key_data &&
                 event->key_data->windows_key_code == mojo::KEYBOARD_CODE_UP) ||
                (event->pointer_data &&
                 event->pointer_data->vertical_wheel > 0)) {
       if (current_page_ > 0) {
         current_page_--;
         DrawBitmap(embedder_for_roots_[view]);
       }
     }
   }
 
-  void OnViewDestroyed(mojo::View* view) override {
+  void OnViewDestroyed(mus::View* view) override {
     DCHECK(embedder_for_roots_.find(view) != embedder_for_roots_.end());
     const auto& it = embedder_for_roots_.find(view);
     DCHECK(it != embedder_for_roots_.end());
     delete it->second;
     embedder_for_roots_.erase(it);
     if (embedder_for_roots_.size() == 0)
       app_.Quit();
   }
 
   // Overridden from mojo::InterfaceFactory<mojo::ViewTreeClient>:
   void Create(
       mojo::ApplicationConnection* connection,
       mojo::InterfaceRequest<mojo::ViewTreeClient> request) override {
-    mojo::ViewTreeConnection::Create(this, request.Pass());
+    mus::ViewTreeConnection::Create(this, request.Pass());
   }
 
   void DrawBitmap(EmbedderData* embedder_data) {
     if (!doc_)
       return;
 
     FPDF_PAGE page = FPDF_LoadPage(doc_, current_page_);
     int width = static_cast<int>(FPDF_GetPageWidth(page));
     int height = static_cast<int>(FPDF_GetPageHeight(page));
 
@@ skipping 28 matching lines @@
   // when we quit (the messageloop is shared among multiple PDFViews).
   void OnTerminate() {
     delete this;
   }
 
   mojo::ApplicationImpl app_;
   std::string data_;
   int current_page_;
   int page_count_;
   FPDF_DOCUMENT doc_;
-  std::map<mojo::View*, EmbedderData*> embedder_for_roots_;
+  std::map<mus::View*, EmbedderData*> embedder_for_roots_;
 
   DISALLOW_COPY_AND_ASSIGN(PDFView);
 };
 
 class ContentHandlerImpl : public mojo::ContentHandler {
  public:
   ContentHandlerImpl(mojo::InterfaceRequest<ContentHandler> request)
       : binding_(this, request.Pass()) {}
   ~ContentHandlerImpl() override {}
 
@@ skipping 38 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PDFViewer);
 };
 
 }  // namespace
 }  // namespace pdf_viewer
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunner runner(new pdf_viewer::PDFViewer());
   return runner.Run(application_request);
 }