Extract NativeAppWindow from src/extensions

components/native_app_window/native_app_window_views.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/native_app_window/native_app_window_views.h"
 
 #include "base/threading/sequenced_worker_pool.h"
+#include "components/native_app_window/app_window_create_params.h"
+#include "components/native_app_window/draggable_region.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
-#include "extensions/browser/app_window/app_window.h"
-#include "extensions/common/draggable_region.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/path.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/window.h"
 #endif
 
-using extensions::AppWindow;
-
 namespace native_app_window {
 
 NativeAppWindowViews::NativeAppWindowViews()
     : app_window_(NULL),
       web_view_(NULL),
       widget_(NULL),
       frameless_(false),
       resizable_(false) {
 }
 
-void NativeAppWindowViews::Init(AppWindow* app_window,
-                                const AppWindow::CreateParams& create_params) {
+void NativeAppWindowViews::Init(NativeAppWindowDelegate* app_window,
+                                const AppWindowCreateParams& create_params) {
   app_window_ = app_window;
-  frameless_ = create_params.frame == AppWindow::FRAME_NONE;
+  frameless_ = create_params.frame == native_app_window::FRAME_NONE;
   resizable_ = create_params.resizable;
   size_constraints_.set_minimum_size(
       create_params.GetContentMinimumSize(gfx::Insets()));
   size_constraints_.set_maximum_size(
       create_params.GetContentMaximumSize(gfx::Insets()));
-  Observe(app_window_->web_contents());
+  Observe(app_window_->GetWebContents());
 
   widget_ = new views::Widget;
   InitializeWindow(app_window, create_params);
 
   OnViewWasResized();
   widget_->AddObserver(this);
 }
 
 NativeAppWindowViews::~NativeAppWindowViews() {
   web_view_->SetWebContents(NULL);
 }
 
 void NativeAppWindowViews::OnCanHaveAlphaEnabledChanged() {
   app_window_->OnNativeWindowChanged();
 }
 
 void NativeAppWindowViews::InitializeWindow(
-    AppWindow* app_window,
-    const AppWindow::CreateParams& create_params) {
+    NativeAppWindowDelegate* app_window,
+    const AppWindowCreateParams& create_params) {
   // Stub implementation. See also ChromeNativeAppWindowViews.
   views::Widget::InitParams init_params(views::Widget::InitParams::TYPE_WINDOW);
   init_params.delegate = this;
   init_params.keep_on_top = create_params.always_on_top;
   widget_->Init(init_params);
   widget_->CenterWindow(
       create_params.GetInitialWindowBounds(gfx::Insets()).size());
 }
 
 // ui::BaseWindow implementation.
@@ skipping 134 matching lines @@
   return web_view_;
 }
 
 bool NativeAppWindowViews::CanResize() const {
   return resizable_ && !size_constraints_.HasFixedSize() &&
          !WidgetHasHitTestMask();
 }
 
 bool NativeAppWindowViews::CanMaximize() const {
   return resizable_ && !size_constraints_.HasMaximumSize() &&
-         !app_window_->window_type_is_panel() && !WidgetHasHitTestMask();
+         !app_window_->WindowTypeIsPanel() && !WidgetHasHitTestMask();
 }
 
 bool NativeAppWindowViews::CanMinimize() const {
   return true;
 }
 
 base::string16 NativeAppWindowViews::GetWindowTitle() const {
   return app_window_->GetTitle();
 }
 
 bool NativeAppWindowViews::ShouldShowWindowTitle() const {
-  return app_window_->window_type() == AppWindow::WINDOW_TYPE_V1_PANEL;
+  return app_window_->GetWindowType() ==
+         native_app_window::WINDOW_TYPE_V1_PANEL;
 }
 
 bool NativeAppWindowViews::ShouldShowWindowIcon() const {
-  return app_window_->window_type() == AppWindow::WINDOW_TYPE_V1_PANEL;
+  return app_window_->GetWindowType() ==
+         native_app_window::WINDOW_TYPE_V1_PANEL;
 }
 
 void NativeAppWindowViews::SaveWindowPlacement(const gfx::Rect& bounds,
                                                ui::WindowShowState show_state) {
   views::WidgetDelegate::SaveWindowPlacement(bounds, show_state);
   app_window_->OnNativeWindowChanged();
 }
 
 void NativeAppWindowViews::DeleteDelegate() {
   widget_->RemoveObserver(this);
   app_window_->OnNativeClose();
 }
 
 views::Widget* NativeAppWindowViews::GetWidget() {
   return widget_;
 }
 
 const views::Widget* NativeAppWindowViews::GetWidget() const {
   return widget_;
 }
 
 views::View* NativeAppWindowViews::GetContentsView() {
   return this;
 }
 
 bool NativeAppWindowViews::ShouldDescendIntoChildForEventHandling(
     gfx::NativeView child,
     const gfx::Point& location) {
 #if defined(USE_AURA)
-  if (child->Contains(web_view_->web_contents()->GetNativeView())) {
+  if (child->Contains(web_view_->GetWebContents()->GetNativeView())) {
     // App window should claim mouse events that fall within the draggable
     // region.
     return !draggable_region_.get() ||
            !draggable_region_->contains(location.x(), location.y());
   }
 #endif
 
   return true;
 }
 
 // WidgetObserver implementation.
 
 void NativeAppWindowViews::OnWidgetVisibilityChanged(views::Widget* widget,
                                                      bool visible) {
   app_window_->OnNativeWindowChanged();
 }
 
 void NativeAppWindowViews::OnWidgetActivationChanged(views::Widget* widget,
                                                      bool active) {
   app_window_->OnNativeWindowChanged();
   if (active)
     app_window_->OnNativeWindowActivated();
 }
 
 // WebContentsObserver implementation.
 
 void NativeAppWindowViews::RenderViewCreated(
     content::RenderViewHost* render_view_host) {
-  if (app_window_->requested_alpha_enabled() && CanHaveAlphaEnabled()) {
+  if (app_window_->RequestedAlphaEnabled() && CanHaveAlphaEnabled()) {
     content::RenderWidgetHostView* view = render_view_host->GetView();
     DCHECK(view);
     view->SetBackgroundOpaque(false);
   }
 }
 
 void NativeAppWindowViews::RenderViewHostChanged(
     content::RenderViewHost* old_host,
     content::RenderViewHost* new_host) {
   OnViewWasResized();
 }
 
 // views::View implementation.
 
 void NativeAppWindowViews::Layout() {
   DCHECK(web_view_);
   web_view_->SetBounds(0, 0, width(), height());
   OnViewWasResized();
 }
 
 void NativeAppWindowViews::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && details.child == this) {
     web_view_ = new views::WebView(NULL);
     AddChildView(web_view_);
-    web_view_->SetWebContents(app_window_->web_contents());
+    web_view_->SetWebContents(app_window_->GetWebContents());
   }
 }
 
 gfx::Size NativeAppWindowViews::GetMinimumSize() const {
   return size_constraints_.GetMinimumSize();
 }
 
 gfx::Size NativeAppWindowViews::GetMaximumSize() const {
   return size_constraints_.GetMaximumSize();
 }
 
 void NativeAppWindowViews::OnFocus() {
   web_view_->RequestFocus();
 }
 
 // NativeAppWindow implementation.
 
 void NativeAppWindowViews::SetFullscreen(int fullscreen_types) {
   // Stub implementation. See also ChromeNativeAppWindowViews.
-  widget_->SetFullscreen(fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
+  widget_->SetFullscreen(fullscreen_types !=
+                         native_app_window::FULLSCREEN_TYPE_NONE);
 }
 
 bool NativeAppWindowViews::IsFullscreenOrPending() const {
   // Stub implementation. See also ChromeNativeAppWindowViews.
   return widget_->IsFullscreen();
 }
 
 void NativeAppWindowViews::UpdateWindowIcon() {
   widget_->UpdateWindowIcon();
 }
 
 void NativeAppWindowViews::UpdateWindowTitle() {
   widget_->UpdateWindowTitle();
 }
 
 void NativeAppWindowViews::UpdateBadgeIcon() {
   // Stub implementation. See also ChromeNativeAppWindowViews.
 }
 
 void NativeAppWindowViews::UpdateDraggableRegions(
-    const std::vector<extensions::DraggableRegion>& regions) {
+    const std::vector<native_app_window::DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
   if (!frameless_)
     return;
 
-  draggable_region_.reset(AppWindow::RawDraggableRegionsToSkRegion(regions));
+  draggable_region_.reset(RawDraggableRegionsToSkRegion(regions));
   OnViewWasResized();
 }
 
 SkRegion* NativeAppWindowViews::GetDraggableRegion() {
   return draggable_region_.get();
 }
 
 void NativeAppWindowViews::UpdateShape(scoped_ptr<SkRegion> region) {
   // Stub implementation. See also ChromeNativeAppWindowViews.
 }
@@ skipping 62 matching lines @@
 
 bool NativeAppWindowViews::CanHaveAlphaEnabled() const {
   return widget_->IsTranslucentWindowOpacitySupported();
 }
 
 void NativeAppWindowViews::SetVisibleOnAllWorkspaces(bool always_visible) {
   widget_->SetVisibleOnAllWorkspaces(always_visible);
 }
 
 }  // namespace native_app_window