[OLD ATTEMPT, DO NOT REVIEW] mustash: Enable connections to mus from the Chrome renderer

content/child/child_thread_impl.cc

 // Copyright (c) 2012 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 "content/child/child_thread_impl.h"
 
 #include <signal.h>
 
 #include <string>
 
+#include "base/process/process_handle.h"
 #include "base/allocator/allocator_extension.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
 #include "base/debug/profiler.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/metrics/field_trial.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "base/tracked_objects.h"
+#include "components/mus/public/cpp/window.h"
+#include "components/mus/public/cpp/window_observer.h"
+#include "components/mus/public/cpp/window_surface.h"
+#include "components/mus/public/cpp/window_tree_connection.h"
+#include "components/mus/public/cpp/window_tree_delegate.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "content/child/child_discardable_shared_memory_manager.h"
 #include "content/child/child_gpu_memory_buffer_manager.h"
 #include "content/child/child_histogram_message_filter.h"
 #include "content/child/child_process.h"
 #include "content/child/child_resource_message_filter.h"
 #include "content/child/child_shared_bitmap_manager.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/fileapi/webfilesystem_impl.h"
 #include "content/child/geofencing/geofencing_message_filter.h"
@@ skipping 12 matching lines @@
 #include "content/common/in_process_child_thread_params.h"
 #include "content/common/mojo/mojo_messages.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/attachment_broker.h"
 #include "ipc/attachment_broker_unprivileged.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ipc/mojo/ipc_channel_mojo.h"
+#include "mojo/application/public/cpp/application_impl.h"
+#include "mojo/converters/geometry/geometry_type_converters.h"
+#include "mojo/converters/surfaces/surfaces_utils.h"
 
 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "content/child/child_io_surface_manager_mac.h"
 #endif
 
 #if defined(USE_OZONE)
@@ skipping 196 matching lines @@
   base::AutoLock lock(lock_);
   while (closure_.is_null())
     cond_var_.Wait();
 
   closure_.Run();
 }
 
 base::LazyInstance<QuitClosure> g_quit_closure = LAZY_INSTANCE_INITIALIZER;
 #endif
 
+class WindowTreeDelegateImpl : public mus::WindowTreeDelegate,
+                               public mus::WindowObserver {
+ public:
+  WindowTreeDelegateImpl() {}
+  ~WindowTreeDelegateImpl() override {}
+
+ private:
+  // WindowTreeDelegateImpl:
+  void OnEmbed(mus::Window* root) override {
+    root->AddObserver(this);
+    fprintf(stderr, ">>>%s root: %p\n", __PRETTY_FUNCTION__, root);

[Fady Samuel, 2015/11/24 04:42:38]

Move this to RenderWidgetViewMus and revert the rest.

+    surface_ = root->RequestSurface(mus::mojom::SURFACE_TYPE_DEFAULT);
+    surface_->BindToThread();
+
+    const gfx::Rect bounds(root->bounds());
+    fprintf(stderr, ">>>%s bounds(%d, %d, %d, %d)\n", __PRETTY_FUNCTION__,
+            bounds.x(), bounds.y(), bounds.width(), bounds.height());
+    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
+    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()));
+
+    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 = false;
+    quad->shared_quad_state_index = 0u;
+
+    mus::mojom::SolidColorQuadStatePtr color_state =
+        mus::mojom::SolidColorQuadState::New();
+    color_state->color = mus::mojom::Color::New();
+    color_state->color->rgba = 0xff00ff00;
+    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());
+    surface_->SubmitCompositorFrame(frame.Pass(), mojo::Closure());
+  }
+
+  void OnUnembed() override {}
+
+  void OnWindowBoundsChanged(mus::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override {
+    // TODO(fsamuel): Update the size of the child content here.
+  }
+
+  void OnConnectionLost(mus::WindowTreeConnection* connection) override {
+    delete this;
+  }
+
+  scoped_ptr<mus::WindowSurface> surface_;
+};
+
 }  // namespace
 
 ChildThread* ChildThread::Get() {
   return ChildThreadImpl::current();
 }
 
 ChildThreadImpl::Options::Options()
     : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID)),
       use_mojo_channel(false) {
@@ skipping 270 matching lines @@
 
 void ChildThreadImpl::OnChannelConnected(int32 peer_pid) {
   channel_connected_factory_.InvalidateWeakPtrs();
 }
 
 void ChildThreadImpl::OnChannelError() {
   set_on_channel_error_called(true);
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
+bool ChildThreadImpl::ConfigureIncomingConnection(
+    mojo::ApplicationConnection* connection) {
+  // TODO(fsamuel): This doens't belong here. We should have this elsewhere.
+  fprintf(stderr, ">>>>>INCOMING CONNECTION %s!!!\n",
+          connection->GetRemoteApplicationURL().c_str());
+  connection->AddService<mus::mojom::WindowTreeClient>(this);
+  return true;
+}
+
+void ChildThreadImpl::Create(
+    mojo::ApplicationConnection* connection,
+    mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request) {
+  fprintf(stderr, ">>>>>WINDOW TREE CLIENT!!!\n");
+  mus::WindowTreeConnection::Create(
+      new WindowTreeDelegateImpl, request.Pass(),
+      mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
+}
+
 bool ChildThreadImpl::Send(IPC::Message* msg) {
   DCHECK(base::MessageLoop::current() == message_loop());
   if (!channel_) {
     delete msg;
     return false;
   }
 
   return channel_->Send(msg);
 }
 
@@ skipping 140 matching lines @@
 #if defined(MOJO_SHELL_CLIENT)
 #if defined(OS_POSIX)
   base::PlatformFile handle = file.fd;
 #elif defined(OS_WIN)
   base::PlatformFile handle = file;
 #endif
   mojo::ScopedMessagePipeHandle message_pipe =
       mojo_shell_channel_init_.Init(handle, GetIOTaskRunner());
   DCHECK(message_pipe.is_valid());
   MojoShellConnectionImpl::CreateWithMessagePipe(message_pipe.Pass());
+  fprintf(stderr, "[%d] >>>%s url: %s\n", base::GetCurrentProcId(),
+          __PRETTY_FUNCTION__,
+          MojoShellConnection::Get()->GetApplication()->url().c_str());
+  MojoShellConnection::Get()->AddListener(this);
 #endif  // defined(MOJO_SHELL_CLIENT)
+  Send(new MojoHostMsg_MojoReady());
 }
 
 #if defined(USE_TCMALLOC)
 void ChildThreadImpl::OnGetTcmallocStats() {
   std::string result;
   char buffer[1024 * 32];
   base::allocator::GetStats(buffer, sizeof(buffer));
   result.append(buffer);
   Send(new ChildProcessHostMsg_TcmallocStats(result));
 }
@@ skipping 31 matching lines @@
 void ChildThreadImpl::EnsureConnected() {
   VLOG(0) << "ChildThreadImpl::EnsureConnected()";
   base::Process::Current().Terminate(0, false);
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return browser_process_io_runner_;
 }
 
 }  // namespace content