Removes WebContentsViewMus/RenderWidgetHostViewMus

content/browser/renderer_host/render_widget_host_view_aura.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <set>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 13 matching lines @@
 #include "cc/trees/layer_tree_settings.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/compositor_resize_lock_aura.h"
+#include "content/browser/renderer_host/delegated_frame_host.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target_aura.h"
 #include "content/browser/renderer_host/input/touch_selection_controller_client_aura.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_input_event_router.h"
 #include "content/browser/renderer_host/render_widget_host_view_event_handler.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/input_messages.h"
+#include "content/common/render_widget_window_tree_client_factory.mojom.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/text_input_state.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/ipc/common/gpu_messages.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
+#include "services/ui/public/interfaces/window_manager_constants.mojom.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/cursor_client_observer.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/client/window_parenting_client.h"
 #include "ui/aura/env.h"
+#include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/blink/web_input_event.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/touch_selection/touch_selection_controller.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/scoped_tooltip_disabler.h"
 #include "ui/wm/public/tooltip_client.h"
-#include "ui/wm/public/window_types.h"
 
 #if defined(OS_WIN)
 #include "base/time/time.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/renderer_host/legacy_render_widget_host_win.h"
 #include "ui/base/win/hidden_window.h"
 #include "ui/base/win/osk_display_manager.h"
 #include "ui/base/win/osk_display_observer.h"
 #include "ui/display/win/screen_win.h"
@@ skipping 97 matching lines @@
   // The current device scale factor.
   float device_scale_factor_;
 
   // The content Window.
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(WinScreenKeyboardObserver);
 };
 #endif  // defined(OS_WIN)
 
+// Callback from embedding the renderer.
+void EmbedCallback(bool result) {
+  if (!result)
+    DVLOG(1) << "embed failed";
+}
+
 }  // namespace
 
 // We need to watch for mouse events outside a Web Popup or its parent
 // and dismiss the popup for certain events.
 class RenderWidgetHostViewAura::EventFilterForPopupExit
     : public ui::EventHandler {
  public:
   explicit EventFilterForPopupExit(RenderWidgetHostViewAura* rwhva)
       : rwhva_(rwhva) {
     DCHECK(rwhva_);
@@ skipping 125 matching lines @@
       ancestor->RemoveObserver(this);
     ancestors_.clear();
   }
 
   RenderWidgetHostViewAura* view_;
   std::set<aura::Window*> ancestors_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowAncestorObserver);
 };
 
+// DelegatedFrameHostClient implementation, not used in mus.
+class RenderWidgetHostViewAura::DelegatedFrameHostClientImpl
+    : public DelegatedFrameHostClient {
+ public:
+  DelegatedFrameHostClientImpl(

[sadrul, 2016/12/16 01:56:20]

explicit

[sky, 2016/12/16 22:30:52]

Done.

+      RenderWidgetHostViewAura* render_widget_host_view)
+      : render_widget_host_view_(render_widget_host_view) {}
+  ~DelegatedFrameHostClientImpl() {}
+
+ private:
+  // DelegatedFrameHostClient implementation.
+  ui::Layer* DelegatedFrameHostGetLayer() const override {
+    return render_widget_host_view_->window_->layer();
+  }
+  bool DelegatedFrameHostIsVisible() const override {
+    return !render_widget_host_view_->host_->is_hidden();
+  }
+  SkColor DelegatedFrameHostGetGutterColor(SkColor color) const override {
+    // When making an element on the page fullscreen the element's background
+    // may not match the page's, so use black as the gutter color to avoid
+    // flashes of brighter colors during the transition.
+    if (render_widget_host_view_->host_->delegate() &&
+        render_widget_host_view_->host_->delegate()
+            ->IsFullscreenForCurrentTab()) {
+      return SK_ColorBLACK;
+    }
+    return color;
+  }
+  gfx::Size DelegatedFrameHostDesiredSizeInDIP() const override {
+    return render_widget_host_view_->window_->bounds().size();
+  }
+  bool DelegatedFrameCanCreateResizeLock() const override {
+#if !defined(OS_CHROMEOS)
+    // On Windows and Linux, holding pointer moves will not help throttling
+    // resizes.
+    // TODO(piman): on Windows we need to block (nested message loop?) the
+    // WM_SIZE event. On Linux we need to throttle at the WM level using
+    // _NET_WM_SYNC_REQUEST.
+    return false;
+#else
+    if (render_widget_host_view_->host_->auto_resize_enabled())
+      return false;
+    return true;
+#endif
+  }
+  std::unique_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
+      bool defer_compositor_lock) override {
+    gfx::Size desired_size = render_widget_host_view_->window_->bounds().size();
+    return std::unique_ptr<ResizeLock>(new CompositorResizeLock(
+        render_widget_host_view_->window_->GetHost(), desired_size,
+        defer_compositor_lock,
+        base::TimeDelta::FromMilliseconds(kResizeLockTimeoutMs)));
+  }
+  void DelegatedFrameHostResizeLockWasReleased() override {
+    render_widget_host_view_->host_->WasResized();
+  }
+  void DelegatedFrameHostSendReclaimCompositorResources(
+      int compositor_frame_sink_id,
+      bool is_swap_ack,
+      const cc::ReturnedResourceArray& resources) override {
+    render_widget_host_view_->host_->Send(
+        new ViewMsg_ReclaimCompositorResources(
+            render_widget_host_view_->host_->GetRoutingID(),
+            compositor_frame_sink_id, is_swap_ack, resources));
+  }
+  void SetBeginFrameSource(cc::BeginFrameSource* source) override {
+    if (render_widget_host_view_->begin_frame_source_ &&
+        render_widget_host_view_->added_frame_observer_) {
+      render_widget_host_view_->begin_frame_source_->RemoveObserver(
+          render_widget_host_view_);
+      render_widget_host_view_->added_frame_observer_ = false;
+    }
+    render_widget_host_view_->begin_frame_source_ = source;
+    render_widget_host_view_->UpdateNeedsBeginFramesInternal();
+  }
+  bool IsAutoResizeEnabled() const override {
+    return render_widget_host_view_->host_->auto_resize_enabled();
+  }
+
+  RenderWidgetHostViewAura* render_widget_host_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelegatedFrameHostClientImpl);
+};
+
+bool IsMus() {
+  return aura::Env::GetInstance()->mode() == aura::Env::Mode::MUS &&
+         base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kUseMusInRenderer);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host,
                                                    bool is_guest_view_hack)
     : host_(RenderWidgetHostImpl::From(host)),
       window_(nullptr),
       in_shutdown_(false),
       in_bounds_changed_(false),
       popup_parent_host_view_(nullptr),
@@ skipping 10 matching lines @@
       legacy_window_destroyed_(false),
       virtual_keyboard_requested_(false),
 #endif
       has_snapped_to_boundary_(false),
       is_guest_view_hack_(is_guest_view_hack),
       device_scale_factor_(0.0f),
       last_active_widget_process_id_(ChildProcessHost::kInvalidUniqueID),
       last_active_widget_routing_id_(MSG_ROUTING_NONE),
       event_handler_(new RenderWidgetHostViewEventHandler(host_, this, this)),
       weak_ptr_factory_(this) {
-  // GuestViews have two RenderWidgetHostViews and so we need to make sure
-  // we don't have FrameSinkId collisions.
-  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
-  cc::FrameSinkId frame_sink_id =
-      is_guest_view_hack_
-          ? factory->GetContextFactoryPrivate()->AllocateFrameSinkId()
-          : cc::FrameSinkId(
-                base::checked_cast<uint32_t>(host_->GetProcess()->GetID()),
-                base::checked_cast<uint32_t>(host_->GetRoutingID()));
-  delegated_frame_host_ =
-      base::MakeUnique<DelegatedFrameHost>(frame_sink_id, this);
-
   if (!is_guest_view_hack_)
     host_->SetView(this);
 
-  // Let the page-level input event router know about our surface ID
-  // namespace for surface-based hit testing.
-  if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
-    host_->delegate()->GetInputEventRouter()->AddFrameSinkIdOwner(
-        GetFrameSinkId(), this);
+  if (!IsMus()) {
+    // GuestViews have two RenderWidgetHostViews and so we need to make sure
+    // we don't have FrameSinkId collisions.
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    cc::FrameSinkId frame_sink_id =
+        is_guest_view_hack_
+            ? factory->GetContextFactoryPrivate()->AllocateFrameSinkId()
+            : cc::FrameSinkId(
+                  base::checked_cast<uint32_t>(host_->GetProcess()->GetID()),
+                  base::checked_cast<uint32_t>(host_->GetRoutingID()));
+    delegated_frame_host_client_ =
+        base::MakeUnique<DelegatedFrameHostClientImpl>(this);
+    delegated_frame_host_ = base::MakeUnique<DelegatedFrameHost>(
+        frame_sink_id, delegated_frame_host_client_.get());
+
+    // Let the page-level input event router know about our surface ID
+    // namespace for surface-based hit testing.
+    if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
+      host_->delegate()->GetInputEventRouter()->AddFrameSinkIdOwner(
+          GetFrameSinkId(), this);
+    }
   }
 
   // We should start observing the TextInputManager for IME-related events as
   // well as monitoring its lifetime.
   if (GetTextInputManager())
     GetTextInputManager()->AddObserver(this);
 
   bool overscroll_enabled = base::CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kOverscrollHistoryNavigation) != "0";
   SetOverscrollControllerEnabled(overscroll_enabled);
 
   selection_controller_client_.reset(
       new TouchSelectionControllerClientAura(this));
   CreateSelectionController();
 
   RenderViewHost* rvh = RenderViewHost::From(host_);
   if (rvh) {
     // TODO(mostynb): actually use prefs.  Landing this as a separate CL
     // first to rebaseline some unreliable layout tests.
     ignore_result(rvh->GetWebkitPreferences());
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
 
 void RenderWidgetHostViewAura::InitAsChild(
     gfx::NativeView parent_view) {
-  CreateAuraWindow();
-  window_->SetType(ui::wm::WINDOW_TYPE_CONTROL);
-  window_->Init(ui::LAYER_SOLID_COLOR);
-  window_->SetName("RenderWidgetHostViewAura");
-  window_->layer()->SetColor(background_color_);
+  CreateAuraWindow(ui::wm::WINDOW_TYPE_CONTROL);
 
   if (parent_view)
     parent_view->AddChild(GetNativeView());
 
   const display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestWindow(window_);
   device_scale_factor_ = display.device_scale_factor();
 }
 
 void RenderWidgetHostViewAura::InitAsPopup(
     RenderWidgetHostView* parent_host_view,
     const gfx::Rect& bounds_in_screen) {
-  CreateAuraWindow();
   popup_parent_host_view_ =
       static_cast<RenderWidgetHostViewAura*>(parent_host_view);
 
   // TransientWindowClient may be NULL during tests.
   aura::client::TransientWindowClient* transient_window_client =
       aura::client::GetTransientWindowClient();
   RenderWidgetHostViewAura* old_child =
       popup_parent_host_view_->popup_child_host_view_;
   if (old_child) {
     // TODO(jhorwich): Allow multiple popup_child_host_view_ per view, or
     // similar mechanism to ensure a second popup doesn't cause the first one
     // to never get a chance to filter events. See crbug.com/160589.
     DCHECK(old_child->popup_parent_host_view_ == popup_parent_host_view_);
     if (transient_window_client) {
       transient_window_client->RemoveTransientChild(
         popup_parent_host_view_->window_, old_child->window_);
     }
     old_child->popup_parent_host_view_ = NULL;
   }
   popup_parent_host_view_->SetPopupChild(this);
-  window_->SetType(ui::wm::WINDOW_TYPE_MENU);
-  window_->Init(ui::LAYER_SOLID_COLOR);
-  window_->SetName("RenderWidgetHostViewAura");
-  window_->layer()->SetColor(background_color_);
+  CreateAuraWindow(ui::wm::WINDOW_TYPE_MENU);
 
   // Setting the transient child allows for the popup to get mouse events when
   // in a system modal dialog. Do this before calling ParentWindowWithContext
   // below so that the transient parent is visible to WindowTreeClient.
   // This fixes crbug.com/328593.
   if (transient_window_client) {
     transient_window_client->AddTransientChild(
         popup_parent_host_view_->window_, window_);
   }
 
   aura::Window* root = popup_parent_host_view_->window_->GetRootWindow();
   aura::client::ParentWindowWithContext(window_, root, bounds_in_screen);
 
   SetBounds(bounds_in_screen);
   Show();
   if (NeedsMouseCapture())
     window_->SetCapture();
 
   event_filter_for_popup_exit_.reset(new EventFilterForPopupExit(this));
 
   const display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestWindow(window_);
   device_scale_factor_ = display.device_scale_factor();
 }
 
 void RenderWidgetHostViewAura::InitAsFullscreen(
     RenderWidgetHostView* reference_host_view) {
-  CreateAuraWindow();
   is_fullscreen_ = true;
-  window_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
-  window_->Init(ui::LAYER_SOLID_COLOR);
-  window_->SetName("RenderWidgetHostViewAura");
+  CreateAuraWindow(ui::wm::WINDOW_TYPE_NORMAL);
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
-  window_->layer()->SetColor(background_color_);
 
   aura::Window* parent = NULL;
   gfx::Rect bounds;
   if (reference_host_view) {
     aura::Window* reference_window =
         static_cast<RenderWidgetHostViewAura*>(reference_host_view)->window_;
     event_handler_->TrackHost(reference_window);
     display::Display display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(reference_window);
     parent = reference_window->GetRootWindow();
@@ skipping 11 matching lines @@
 RenderWidgetHost* RenderWidgetHostViewAura::GetRenderWidgetHost() const {
   return host_;
 }
 
 void RenderWidgetHostViewAura::Show() {
   window_->Show();
 
   if (!host_->is_hidden())
     return;
 
-  bool has_saved_frame = delegated_frame_host_->HasSavedFrame();
+  bool has_saved_frame =
+      delegated_frame_host_ ? delegated_frame_host_->HasSavedFrame() : false;
   ui::LatencyInfo renderer_latency_info, browser_latency_info;
   if (has_saved_frame) {
     browser_latency_info.AddLatencyNumber(
         ui::TAB_SHOW_COMPONENT, host_->GetLatencyComponentId(), 0);
   } else {
     renderer_latency_info.AddLatencyNumber(
         ui::TAB_SHOW_COMPONENT, host_->GetLatencyComponentId(), 0);
   }
   host_->WasShown(renderer_latency_info);
 
   aura::Window* root = window_->GetRootWindow();
   if (root) {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(root);
     if (cursor_client)
       NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
 
-  delegated_frame_host_->WasShown(browser_latency_info);
+  if (delegated_frame_host_)
+    delegated_frame_host_->WasShown(browser_latency_info);
 
 #if defined(OS_WIN)
   UpdateLegacyWin();
 #endif
 }
 
 void RenderWidgetHostViewAura::Hide() {
   window_->Hide();
 
   // TODO(wjmaclean): can host_ ever be null?
   if (host_ && !host_->is_hidden()) {
     host_->WasHidden();
-    delegated_frame_host_->WasHidden();
+    if (delegated_frame_host_)
+      delegated_frame_host_->WasHidden();
 
 #if defined(OS_WIN)
     aura::WindowTreeHost* host = window_->GetHost();
     if (host) {
       // We reparent the legacy Chrome_RenderWidgetHostHWND window to the global
       // hidden window on the same lines as Windowed plugin windows.
       if (legacy_render_widget_host_HWND_)
         legacy_render_widget_host_HWND_->UpdateParent(ui::GetHiddenWindow());
     }
 #endif
@@ skipping 150 matching lines @@
   aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
   if (client)
     window_->Focus();
 }
 
 bool RenderWidgetHostViewAura::HasFocus() const {
   return window_->HasFocus();
 }
 
 bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
-  return delegated_frame_host_->CanCopyToBitmap();
+  return delegated_frame_host_ ? delegated_frame_host_->CanCopyToBitmap()
+                               : false;
 }
 
 bool RenderWidgetHostViewAura::IsShowing() {
   return window_->IsVisible();
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetViewBounds() const {
   return window_->GetBoundsInScreen();
 }
 
@@ skipping 86 matching lines @@
   aura::client::TooltipClient* tooltip_client =
       aura::client::GetTooltipClient(root_window);
   if (tooltip_client) {
     tooltip_client->UpdateTooltip(window_);
     // Content tooltips should be visible indefinitely.
     tooltip_client->SetTooltipShownTimeout(window_, 0);
   }
 }
 
 gfx::Size RenderWidgetHostViewAura::GetRequestedRendererSize() const {
-  return delegated_frame_host_->GetRequestedRendererSize();
+  return delegated_frame_host_
+             ? delegated_frame_host_->GetRequestedRendererSize()
+             : RenderWidgetHostViewBase::GetRequestedRendererSize();
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const ReadbackRequestCallback& callback,
     const SkColorType preferred_color_type) {
+  if (!delegated_frame_host_)
+    return;
   delegated_frame_host_->CopyFromCompositingSurface(
       src_subrect, dst_size, callback, preferred_color_type);
 }
 
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
+  if (!delegated_frame_host_)
+    return;
   delegated_frame_host_->CopyFromCompositingSurfaceToVideoFrame(
       src_subrect, target, callback);
 }
 
 bool RenderWidgetHostViewAura::CanCopyToVideoFrame() const {
-  return delegated_frame_host_->CanCopyToVideoFrame();
+  return delegated_frame_host_ ? delegated_frame_host_->CanCopyToVideoFrame()
+                               : false;
 }
 
 void RenderWidgetHostViewAura::BeginFrameSubscription(
     std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
-  delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
+  if (delegated_frame_host_)
+    delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
 }
 
 void RenderWidgetHostViewAura::EndFrameSubscription() {
-  delegated_frame_host_->EndFrameSubscription();
+  if (delegated_frame_host_)
+    delegated_frame_host_->EndFrameSubscription();
 }
 
 #if defined(OS_WIN)
 bool RenderWidgetHostViewAura::UsesNativeWindowFrame() const {
   return (legacy_render_widget_host_HWND_ != NULL);
 }
 
 void RenderWidgetHostViewAura::UpdateMouseLockRegion() {
   RECT window_rect =
       display::Screen::GetScreen()
@@ skipping 33 matching lines @@
 
     start_edge_top.Scale(viewportToDIPScale);
     start_edge_bottom.Scale(viewportToDIPScale);
     end_edge_top.Scale(viewportToDIPScale);
     end_edge_bottom.Scale(viewportToDIPScale);
 
     selection.start.SetEdge(start_edge_top, start_edge_bottom);
     selection.end.SetEdge(end_edge_top, end_edge_bottom);
   }
 
-  delegated_frame_host_->SwapDelegatedFrame(compositor_frame_sink_id,
-                                            std::move(frame));
+  if (delegated_frame_host_) {
+    delegated_frame_host_->SwapDelegatedFrame(compositor_frame_sink_id,
+                                              std::move(frame));
+  }
   SelectionUpdated(selection.is_editable, selection.is_empty_text_form_control,
                    selection.start, selection.end);
 }
 
 void RenderWidgetHostViewAura::ClearCompositorFrame() {
-  delegated_frame_host_->ClearDelegatedFrame();
+  if (delegated_frame_host_)
+    delegated_frame_host_->ClearDelegatedFrame();
 }
 
 void RenderWidgetHostViewAura::DidStopFlinging() {
   selection_controller_client_->OnScrollCompleted();
 }
 
 bool RenderWidgetHostViewAura::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   // Aura doesn't use GetBackingStore for accelerated pages, so it doesn't
   // matter what is returned here as GetBackingStore is the only caller of this
@@ skipping 638 matching lines @@
 cc::FrameSinkId RenderWidgetHostViewAura::FrameSinkIdAtPoint(
     cc::SurfaceHittestDelegate* delegate,
     const gfx::Point& point,
     gfx::Point* transformed_point) {
   DCHECK(device_scale_factor_ != 0.0f);
 
   // The surface hittest happens in device pixels, so we need to convert the
   // |point| from DIPs to pixels before hittesting.
   gfx::Point point_in_pixels =
       gfx::ConvertPointToPixel(device_scale_factor_, point);
-  cc::SurfaceId id = delegated_frame_host_->SurfaceIdAtPoint(
-      delegate, point_in_pixels, transformed_point);
+  cc::SurfaceId id = delegated_frame_host_
+                         ? delegated_frame_host_->SurfaceIdAtPoint(
+                               delegate, point_in_pixels, transformed_point)
+                         : cc::SurfaceId();
   *transformed_point =

[sadrul, 2016/12/16 01:56:20]

We should ideally not even reach here in mus (since this is used for
hit-testing, and in mus, we will not be doing hit-testing in chrome browser).

[sky, 2016/12/16 22:30:52]

I added a TODO.

       gfx::ConvertPointToDIP(device_scale_factor_, *transformed_point);
 
   // It is possible that the renderer has not yet produced a surface, in which
   // case we return our current namespace.
   if (!id.is_valid())
     return GetFrameSinkId();
   return id.frame_sink_id();
 }
 
 void RenderWidgetHostViewAura::ProcessMouseEvent(
@@ skipping 21 matching lines @@
 }
 
 bool RenderWidgetHostViewAura::TransformPointToLocalCoordSpace(
     const gfx::Point& point,
     const cc::SurfaceId& original_surface,
     gfx::Point* transformed_point) {
   // Transformations use physical pixels rather than DIP, so conversion
   // is necessary.
   gfx::Point point_in_pixels =
       gfx::ConvertPointToPixel(device_scale_factor_, point);
-  if (!delegated_frame_host_->TransformPointToLocalCoordSpace(
+  if (delegated_frame_host_ &&

[sadrul, 2016/12/16 01:56:20]

ditto

[sky, 2016/12/16 22:30:52]

TODO here too.

+      !delegated_frame_host_->TransformPointToLocalCoordSpace(
           point_in_pixels, original_surface, transformed_point))
     return false;
   *transformed_point =
       gfx::ConvertPointToDIP(device_scale_factor_, *transformed_point);
   return true;
 }
 
 bool RenderWidgetHostViewAura::TransformPointToCoordSpaceForView(
     const gfx::Point& point,
     RenderWidgetHostViewBase* target_view,
     gfx::Point* transformed_point) {
-  if (target_view == this) {
+  if (target_view == this || !delegated_frame_host_) {
     *transformed_point = point;
     return true;
   }
 
   // In TransformPointToLocalCoordSpace() there is a Point-to-Pixel conversion,
   // but it is not necessary here because the final target view is responsible
   // for converting before computing the final transform.
   return delegated_frame_host_->TransformPointToCoordSpaceForView(
       point, target_view, transformed_point);
 }
@@ skipping 187 matching lines @@
     DCHECK(osk_display_manager);
     osk_display_manager->RemoveObserver(keyboard_observer_.get());
   }
 
 #endif
 
   if (text_input_manager_)
     text_input_manager_->RemoveObserver(this);
 }
 
-void RenderWidgetHostViewAura::CreateAuraWindow() {
+void RenderWidgetHostViewAura::CreateAuraWindow(ui::wm::WindowType type) {
   DCHECK(!window_);
   window_ = new aura::Window(this);
+  window_->SetName("RenderWidgetHostViewAura");
   event_handler_->set_window(window_);
   window_observer_.reset(new WindowObserver(this));
 
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   display::Screen::GetScreen()->AddObserver(this);
+
+  window_->SetType(type);
+  window_->Init(ui::LAYER_SOLID_COLOR);
+  window_->layer()->SetColor(background_color_);
+
+  if (!IsMus())
+    return;
+
+  // Connect to the renderer, pass it a WindowTreeClient interface request
+  // and embed that client inside our mus window.
+  mojom::RenderWidgetWindowTreeClientFactoryPtr factory;
+  host_->GetProcess()->GetRemoteInterfaces()->GetInterface(&factory);
+
+  ui::mojom::WindowTreeClientPtr window_tree_client;
+  factory->CreateWindowTreeClientForRenderWidget(
+      host_->GetRoutingID(), mojo::GetProxy(&window_tree_client));
+  aura::WindowPortMus::Get(window_)->Embed(
+      std::move(window_tree_client),
+      ui::mojom::kEmbedFlagEmbedderInterceptsEvents,
+      base::Bind(&EmbedCallback));
 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
   if (host_->GetProcess()->FastShutdownStarted())
     return;
 
   aura::Window* root_window = window_->GetRootWindow();
   if (!root_window)
     return;
 
@@ skipping 158 matching lines @@
   CreateSelectionController();
 }
 
 void RenderWidgetHostViewAura::InternalSetBounds(const gfx::Rect& rect) {
   SnapToPhysicalPixelBoundary();
   // Don't recursively call SetBounds if this bounds update is the result of
   // a Window::SetBoundsInternal call.
   if (!in_bounds_changed_)
     window_->SetBounds(rect);
   host_->WasResized();
-  delegated_frame_host_->WasResized();
+  if (delegated_frame_host_)
+    delegated_frame_host_->WasResized();
 #if defined(OS_WIN)
   UpdateLegacyWin();
 
   if (mouse_locked_)
     UpdateMouseLockRegion();
 #endif
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::UpdateLegacyWin() {
@@ skipping 45 matching lines @@
   if (HasFocus()) {
     ui::InputMethod* input_method = GetInputMethod();
     if (input_method)
       input_method->SetFocusedTextInputClient(this);
   }
 
 #if defined(OS_WIN)
   UpdateLegacyWin();
 #endif
 
-  delegated_frame_host_->SetCompositor(window_->GetHost()->compositor());
+  if (delegated_frame_host_)
+    delegated_frame_host_->SetCompositor(window_->GetHost()->compositor());
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   DetachFromInputMethod();
 
   window_->GetHost()->RemoveObserver(this);
-  delegated_frame_host_->ResetCompositor();
+  if (delegated_frame_host_)
+    delegated_frame_host_->ResetCompositor();
 
 #if defined(OS_WIN)
   // Update the legacy window's parent temporarily to the hidden window. It
   // will eventually get reparented to the right root.
   if (legacy_render_widget_host_HWND_)
     legacy_render_widget_host_HWND_->UpdateParent(ui::GetHiddenWindow());
 #endif
 }
 
 void RenderWidgetHostViewAura::DetachFromInputMethod() {
@@ skipping 53 matching lines @@
   ui::TouchSelectionController::Config tsc_config;
   tsc_config.max_tap_duration = base::TimeDelta::FromMilliseconds(
       ui::GestureConfiguration::GetInstance()->long_press_time_in_ms());
   tsc_config.tap_slop = ui::GestureConfiguration::GetInstance()
                             ->max_touch_move_in_pixels_for_click();
   tsc_config.enable_longpress_drag_selection = false;
   selection_controller_.reset(new ui::TouchSelectionController(
       selection_controller_client_.get(), tsc_config));
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// DelegatedFrameHost, public:
-
-ui::Layer* RenderWidgetHostViewAura::DelegatedFrameHostGetLayer() const {
-  return window_->layer();
-}
-
-bool RenderWidgetHostViewAura::DelegatedFrameHostIsVisible() const {
-  return !host_->is_hidden();
-}
-
-SkColor RenderWidgetHostViewAura::DelegatedFrameHostGetGutterColor(
-    SkColor color) const {
-  // When making an element on the page fullscreen the element's background
-  // may not match the page's, so use black as the gutter color to avoid
-  // flashes of brighter colors during the transition.
-  if (host_->delegate() && host_->delegate()->IsFullscreenForCurrentTab())
-    return SK_ColorBLACK;
-  return color;
-}
-
-gfx::Size RenderWidgetHostViewAura::DelegatedFrameHostDesiredSizeInDIP() const {
-  return window_->bounds().size();
-}
-
-bool RenderWidgetHostViewAura::DelegatedFrameCanCreateResizeLock() const {
-#if !defined(OS_CHROMEOS)
-  // On Windows and Linux, holding pointer moves will not help throttling
-  // resizes.
-  // TODO(piman): on Windows we need to block (nested message loop?) the
-  // WM_SIZE event. On Linux we need to throttle at the WM level using
-  // _NET_WM_SYNC_REQUEST.
-  return false;
-#else
-  if (host_->auto_resize_enabled())
-    return false;
-  return true;
-#endif
-}
-
-std::unique_ptr<ResizeLock>
-RenderWidgetHostViewAura::DelegatedFrameHostCreateResizeLock(
-    bool defer_compositor_lock) {
-  gfx::Size desired_size = window_->bounds().size();
-  return std::unique_ptr<ResizeLock>(new CompositorResizeLock(
-      window_->GetHost(), desired_size, defer_compositor_lock,
-      base::TimeDelta::FromMilliseconds(kResizeLockTimeoutMs)));
-}
-
-void RenderWidgetHostViewAura::DelegatedFrameHostResizeLockWasReleased() {
-  host_->WasResized();
-}
-
-void RenderWidgetHostViewAura::DelegatedFrameHostSendReclaimCompositorResources(
-    int compositor_frame_sink_id,
-    bool is_swap_ack,
-    const cc::ReturnedResourceArray& resources) {
-  host_->Send(new ViewMsg_ReclaimCompositorResources(
-      host_->GetRoutingID(), compositor_frame_sink_id, is_swap_ack, resources));
-}
-
-void RenderWidgetHostViewAura::SetBeginFrameSource(
-    cc::BeginFrameSource* source) {
-  if (begin_frame_source_ && added_frame_observer_) {
-    begin_frame_source_->RemoveObserver(this);
-    added_frame_observer_ = false;
-  }
-  begin_frame_source_ = source;
-  UpdateNeedsBeginFramesInternal();
-}
-
-bool RenderWidgetHostViewAura::IsAutoResizeEnabled() const {
-  return host_->auto_resize_enabled();
-}
-
 void RenderWidgetHostViewAura::OnDidNavigateMainFrameToNewPage() {
   ui::GestureRecognizer::Get()->CancelActiveTouches(window_);
 }
 
 void RenderWidgetHostViewAura::LockCompositingSurface() {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAura::UnlockCompositingSurface() {
   NOTIMPLEMENTED();
 }
 
 cc::FrameSinkId RenderWidgetHostViewAura::GetFrameSinkId() {
-  return delegated_frame_host_->GetFrameSinkId();
+  return delegated_frame_host_ ? delegated_frame_host_->GetFrameSinkId()
+                               : cc::FrameSinkId();
 }
 
 cc::SurfaceId RenderWidgetHostViewAura::SurfaceIdForTesting() const {
-  return delegated_frame_host_->SurfaceIdForTesting();
+  return delegated_frame_host_ ? delegated_frame_host_->SurfaceIdForTesting()
+                               : cc::SurfaceId();
 }
 
 void RenderWidgetHostViewAura::OnUpdateTextInputStateCalled(
     TextInputManager* text_input_manager,
     RenderWidgetHostViewBase* updated_view,
     bool did_update_state) {
   DCHECK_EQ(text_input_manager_, text_input_manager);
 
   if (!GetInputMethod())
     return;
@@ skipping 83 matching lines @@
 
 void RenderWidgetHostViewAura::SetPopupChild(
     RenderWidgetHostViewAura* popup_child_host_view) {
   popup_child_host_view_ = popup_child_host_view;
   event_handler_->SetPopupChild(
       popup_child_host_view,
       popup_child_host_view ? popup_child_host_view->event_handler() : nullptr);
 }
 
 }  // namespace content