components/mus/public/interfaces View => Window

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/window.h"
@@ skipping 38 matching lines @@
 namespace pdf_viewer {
 namespace {
 
 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 {
+class BitmapUploader : public mus::mojom::SurfaceClient {
  public:
   explicit BitmapUploader(mus::Window* 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) {}
   ~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());
     request2->url = mojo::String::From("mojo:mus");
     shell->ConnectToApplication(request2.Pass(),
                                 mojo::GetProxy(&gpu_service_provider), nullptr,
                                 nullptr, base::Bind(&OnGotContentHandlerID));
     ConnectToService(gpu_service_provider.get(), &gpu_service_);
 
-    mojo::CommandBufferPtr gles2_client;
+    mus::mojom::CommandBufferPtr gles2_client;
     gpu_service_->CreateOffscreenGLES2Context(GetProxy(&gles2_client));
     gles2_context_ = MojoGLES2CreateContext(
         gles2_client.PassInterface().PassHandle().release().value(),
         nullptr,
         &LostContext, NULL, mojo::Environment::GetDefaultAsyncWaiter());
     MojoGLES2MakeCurrent(gles2_context_);
   }
 
   // Sets the color which is RGBA.
   void SetColor(uint32_t color) {
@@ skipping 18 matching lines @@
     height_ = height;
     bitmap_ = data.Pass();
     format_ = format;
     if (surface_)
       Upload();
   }
 
  private:
   void Upload() {
     gfx::Rect bounds(view_->bounds().To<gfx::Rect>());
-    mojo::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
-    mojo::CompositorFramePtr frame = mojo::CompositorFrame::New();
+    mus::mojom::PassPtr pass = mojo::CreateDefaultPass(1, bounds);
+    mus::mojom::CompositorFramePtr frame = mus::mojom::CompositorFrame::New();
 
     // TODO(rjkroege): Support device scale factor in PDF viewer
-    mojo::CompositorFrameMetadataPtr meta =
-        mojo::CompositorFrameMetadata::New();
+    mus::mojom::CompositorFrameMetadataPtr meta =
+        mus::mojom::CompositorFrameMetadata::New();
     meta->device_scale_factor = 1.0f;
     frame->metadata = meta.Pass();
 
     frame->resources.resize(0u);
 
     pass->quads.resize(0u);
     pass->shared_quad_states.push_back(
         mojo::CreateDefaultSQS(bounds.size()));
 
     MojoGLES2MakeCurrent(gles2_context_);
@@ skipping 10 matching lines @@
                       bitmap_size.height,
                       TextureFormat(),
                       GL_UNSIGNED_BYTE,
                       &((*bitmap_)[0]));
 
       GLbyte mailbox[GL_MAILBOX_SIZE_CHROMIUM];
       glGenMailboxCHROMIUM(mailbox);
       glProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox);
       GLuint sync_point = glInsertSyncPointCHROMIUM();
 
-      mojo::TransferableResourcePtr resource =
-          mojo::TransferableResource::New();
+      mus::mojom::TransferableResourcePtr resource =
+          mus::mojom::TransferableResource::New();
       resource->id = next_resource_id_++;
       resource_to_texture_id_map_[resource->id] = texture_id;
-      resource->format = mojo::RESOURCE_FORMAT_RGBA_8888;
+      resource->format = mus::mojom::RESOURCE_FORMAT_RGBA_8888;
       resource->filter = GL_LINEAR;
       resource->size = bitmap_size.Clone();
-      mojo::MailboxHolderPtr mailbox_holder = mojo::MailboxHolder::New();
-      mailbox_holder->mailbox = mojo::Mailbox::New();
+      mus::mojom::MailboxHolderPtr mailbox_holder =
+          mus::mojom::MailboxHolder::New();
+      mailbox_holder->mailbox = mus::mojom::Mailbox::New();
       for (int i = 0; i < GL_MAILBOX_SIZE_CHROMIUM; ++i)
         mailbox_holder->mailbox->name.push_back(mailbox[i]);
       mailbox_holder->texture_target = GL_TEXTURE_2D;
       mailbox_holder->sync_point = sync_point;
       resource->mailbox_holder = mailbox_holder.Pass();
       resource->is_repeated = false;
       resource->is_software = false;
 
-      mojo::QuadPtr quad = mojo::Quad::New();
-      quad->material = mojo::MATERIAL_TEXTURE_CONTENT;
+      mus::mojom::QuadPtr quad = mus::mojom::Quad::New();
+      quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
 
       mojo::RectPtr rect = mojo::Rect::New();
       if (width_ <= bounds.width() && height_ <= bounds.height()) {
         rect->width = width_;
         rect->height = height_;
       } else {
         // The source bitmap is larger than the viewport. Resize it while
         // maintaining the aspect ratio.
         float width_ratio = static_cast<float>(width_) / bounds.width();
         float height_ratio = static_cast<float>(height_) / bounds.height();
         if (width_ratio > height_ratio) {
           rect->width = bounds.width();
           rect->height = height_ / width_ratio;
         } else {
           rect->height = bounds.height();
           rect->width = width_ / height_ratio;
         }
       }
       quad->rect = rect.Clone();
       quad->opaque_rect = rect.Clone();
       quad->visible_rect = rect.Clone();
       quad->needs_blending = true;
       quad->shared_quad_state_index = 0u;
 
-      mojo::TextureQuadStatePtr texture_state = mojo::TextureQuadState::New();
+      mus::mojom::TextureQuadStatePtr texture_state =
+          mus::mojom::TextureQuadState::New();
       texture_state->resource_id = resource->id;
       texture_state->premultiplied_alpha = true;
       texture_state->uv_top_left = mojo::PointF::New();
       texture_state->uv_bottom_right = mojo::PointF::New();
       texture_state->uv_bottom_right->x = 1.f;
       texture_state->uv_bottom_right->y = 1.f;
-      texture_state->background_color = mojo::Color::New();
+      texture_state->background_color = mus::mojom::Color::New();
       texture_state->background_color->rgba = g_transparent_color;
       for (int i = 0; i < 4; ++i)
         texture_state->vertex_opacity.push_back(1.f);
       texture_state->y_flipped = false;
 
       frame->resources.push_back(resource.Pass());
       quad->texture_quad_state = texture_state.Pass();
       pass->quads.push_back(quad.Pass());
     }
 
     if (color_ != g_transparent_color) {
-      mojo::QuadPtr quad = mojo::Quad::New();
-      quad->material = mojo::MATERIAL_SOLID_COLOR;
+      mus::mojom::QuadPtr quad = mus::mojom::Quad::New();
+      quad->material = mus::mojom::MATERIAL_SOLID_COLOR;
       quad->rect = mojo::Rect::From(bounds);
       quad->opaque_rect = mojo::Rect::New();
       quad->visible_rect = mojo::Rect::From(bounds);
       quad->needs_blending = true;
       quad->shared_quad_state_index = 0u;
 
-      mojo::SolidColorQuadStatePtr color_state =
-          mojo::SolidColorQuadState::New();
-      color_state->color = mojo::Color::New();
+      mus::mojom::SolidColorQuadStatePtr color_state =
+          mus::mojom::SolidColorQuadState::New();
+      color_state->color = mus::mojom::Color::New();
       color_state->color->rgba = color_;
       color_state->force_anti_aliasing_off = false;
 
       quad->solid_color_quad_state = color_state.Pass();
       pass->quads.push_back(quad.Pass());
     }
 
     frame->passes.push_back(pass.Pass());
 
     // TODO(rjkroege, fsamuel): We should throttle frames.
@@ skipping 23 matching lines @@
   }
 
   void SetIdNamespace(uint32_t id_namespace) {
     id_namespace_ = id_namespace;
     if (color_ != g_transparent_color || bitmap_.get())
       Upload();
   }
 
   // SurfaceClient implementation.
   void ReturnResources(
-      mojo::Array<mojo::ReturnedResourcePtr> resources) override {
+      mojo::Array<mus::mojom::ReturnedResourcePtr> resources) override {
     MojoGLES2MakeCurrent(gles2_context_);
     // TODO(jamesr): Recycle.
     for (size_t i = 0; i < resources.size(); ++i) {
-      mojo::ReturnedResourcePtr resource = resources[i].Pass();
+      mus::mojom::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);
     }
   }
 
   mus::Window* view_;
-  mojo::GpuPtr gpu_service_;
+  mus::mojom::GpuPtr gpu_service_;
   scoped_ptr<mus::WindowSurface> 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_;
+  mojo::Binding<mus::mojom::SurfaceClient> returner_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(BitmapUploader);
 };
 
 class EmbedderData {
  public:
   EmbedderData(mojo::Shell* shell, mus::Window* 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 mus::WindowTreeDelegate,
                 public mus::WindowObserver,
-                public mojo::InterfaceFactory<mojo::ViewTreeClient> {
+                public mojo::InterfaceFactory<mus::mojom::WindowTreeClient> {
  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);
+    connection->AddService<mus::mojom::WindowTreeClient>(this);
     return true;
   }
 
   // Overridden from WindowTreeDelegate:
   void OnEmbed(mus::Window* 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);
@@ skipping 40 matching lines @@
   void OnWindowDestroyed(mus::Window* 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>:
+  // Overridden from mojo::InterfaceFactory<mus::mojom::WindowTreeClient>:
   void Create(
       mojo::ApplicationConnection* connection,
-      mojo::InterfaceRequest<mojo::ViewTreeClient> request) override {
+      mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request) override {
     mus::WindowTreeConnection::Create(
         this, request.Pass(),
         mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
   }
 
   void DrawBitmap(EmbedderData* embedder_data) {
     if (!doc_)
       return;
 
     FPDF_PAGE page = FPDF_LoadPage(doc_, current_page_);
@@ skipping 90 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);
 }