Componentize NativeAppWindowViews

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 "apps/ui/views/native_app_window_views.h"
+#include "components/native_app_window/native_app_window_views.h"
 
 #include "base/threading/sequenced_worker_pool.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 apps {
+namespace native_app_window {
 
 NativeAppWindowViews::NativeAppWindowViews()
     : app_window_(NULL),
       web_view_(NULL),
       widget_(NULL),
       frameless_(false),
-      resizable_(false) {}
+      resizable_(false) {
+}
 
 void NativeAppWindowViews::Init(AppWindow* app_window,
                                 const AppWindow::CreateParams& create_params) {
   app_window_ = app_window;
   frameless_ = create_params.frame == AppWindow::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()));
@@ skipping 21 matching lines @@
   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.
 
-bool NativeAppWindowViews::IsActive() const { return widget_->IsActive(); }
+bool NativeAppWindowViews::IsActive() const {
+  return widget_->IsActive();
+}
 
 bool NativeAppWindowViews::IsMaximized() const {
   return widget_->IsMaximized();
 }
 
 bool NativeAppWindowViews::IsMinimized() const {
   return widget_->IsMinimized();
 }
 
 bool NativeAppWindowViews::IsFullscreen() const {
@@ skipping 29 matching lines @@
   widget_->Show();
 }
 
 void NativeAppWindowViews::ShowInactive() {
   if (widget_->IsVisible())
     return;
 
   widget_->ShowInactive();
 }
 
-void NativeAppWindowViews::Hide() { widget_->Hide(); }
+void NativeAppWindowViews::Hide() {
+  widget_->Hide();
+}
 
-void NativeAppWindowViews::Close() { widget_->Close(); }
+void NativeAppWindowViews::Close() {
+  widget_->Close();
+}
 
-void NativeAppWindowViews::Activate() { widget_->Activate(); }
+void NativeAppWindowViews::Activate() {
+  widget_->Activate();
+}
 
-void NativeAppWindowViews::Deactivate() { widget_->Deactivate(); }
+void NativeAppWindowViews::Deactivate() {
+  widget_->Deactivate();
+}
 
-void NativeAppWindowViews::Maximize() { widget_->Maximize(); }
+void NativeAppWindowViews::Maximize() {
+  widget_->Maximize();
+}
 
-void NativeAppWindowViews::Minimize() { widget_->Minimize(); }
+void NativeAppWindowViews::Minimize() {
+  widget_->Minimize();
+}
 
-void NativeAppWindowViews::Restore() { widget_->Restore(); }
+void NativeAppWindowViews::Restore() {
+  widget_->Restore();
+}
 
 void NativeAppWindowViews::SetBounds(const gfx::Rect& bounds) {
   widget_->SetBounds(bounds);
 }
 
 void NativeAppWindowViews::FlashFrame(bool flash) {
   widget_->FlashFrame(flash);
 }
 
 bool NativeAppWindowViews::IsAlwaysOnTop() const {
@@ skipping 70 matching lines @@
                                                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_; }
+views::Widget* NativeAppWindowViews::GetWidget() {
+  return widget_;
+}
 
-const views::Widget* NativeAppWindowViews::GetWidget() const { 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())) {
@@ skipping 72 matching lines @@
 void NativeAppWindowViews::SetFullscreen(int fullscreen_types) {
   // Stub implementation. See also ChromeNativeAppWindowViews.
   widget_->SetFullscreen(fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
 }
 
 bool NativeAppWindowViews::IsFullscreenOrPending() const {
   // Stub implementation. See also ChromeNativeAppWindowViews.
   return widget_->IsFullscreen();
 }
 
-void NativeAppWindowViews::UpdateWindowIcon() { widget_->UpdateWindowIcon(); }
+void NativeAppWindowViews::UpdateWindowIcon() {
+  widget_->UpdateWindowIcon();
+}
 
-void NativeAppWindowViews::UpdateWindowTitle() { widget_->UpdateWindowTitle(); }
+void NativeAppWindowViews::UpdateWindowTitle() {
+  widget_->UpdateWindowTitle();
+}
 
 void NativeAppWindowViews::UpdateBadgeIcon() {
   // Stub implementation. See also ChromeNativeAppWindowViews.
 }
 
 void NativeAppWindowViews::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
   if (!frameless_)
     return;
 
   draggable_region_.reset(AppWindow::RawDraggableRegionsToSkRegion(regions));
   OnViewWasResized();
 }
 
 SkRegion* NativeAppWindowViews::GetDraggableRegion() {
   return draggable_region_.get();
 }
 
 void NativeAppWindowViews::UpdateShape(scoped_ptr<SkRegion> region) {
   // Stub implementation. See also ChromeNativeAppWindowViews.
 }
 
 void NativeAppWindowViews::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   unhandled_keyboard_event_handler_.HandleKeyboardEvent(event,
                                                         GetFocusManager());
 }
 
-bool NativeAppWindowViews::IsFrameless() const { return frameless_; }
+bool NativeAppWindowViews::IsFrameless() const {
+  return frameless_;
+}
 
-bool NativeAppWindowViews::HasFrameColor() const { return false; }
+bool NativeAppWindowViews::HasFrameColor() const {
+  return false;
+}
 
 SkColor NativeAppWindowViews::ActiveFrameColor() const {
   return SK_ColorBLACK;
 }
 
 SkColor NativeAppWindowViews::InactiveFrameColor() const {
   return SK_ColorBLACK;
 }
 
 gfx::Insets NativeAppWindowViews::GetFrameInsets() const {
   if (frameless_)
     return gfx::Insets();
 
   // The pretend client_bounds passed in need to be large enough to ensure that
   // GetWindowBoundsForClientBounds() doesn't decide that it needs more than
   // the specified amount of space to fit the window controls in, and return a
   // number larger than the real frame insets. Most window controls are smaller
   // than 1000x1000px, so this should be big enough.
   gfx::Rect client_bounds = gfx::Rect(1000, 1000);
   gfx::Rect window_bounds =
       widget_->non_client_view()->GetWindowBoundsForClientBounds(client_bounds);
   return window_bounds.InsetsFrom(client_bounds);
 }
 
-void NativeAppWindowViews::HideWithApp() {}
+void NativeAppWindowViews::HideWithApp() {
+}
 
-void NativeAppWindowViews::ShowWithApp() {}
+void NativeAppWindowViews::ShowWithApp() {
+}
 
-void NativeAppWindowViews::UpdateShelfMenu() {}
+void NativeAppWindowViews::UpdateShelfMenu() {
+}
 
 gfx::Size NativeAppWindowViews::GetContentMinimumSize() const {
   return size_constraints_.GetMinimumSize();
 }
 
 gfx::Size NativeAppWindowViews::GetContentMaximumSize() const {
   return size_constraints_.GetMaximumSize();
 }
 
 void NativeAppWindowViews::SetContentSizeConstraints(
-    const gfx::Size& min_size, const gfx::Size& max_size) {
+    const gfx::Size& min_size,
+    const gfx::Size& max_size) {
   size_constraints_.set_minimum_size(min_size);
   size_constraints_.set_maximum_size(max_size);
   widget_->OnSizeConstraintsChanged();
 }
 
 bool NativeAppWindowViews::CanHaveAlphaEnabled() const {
   return widget_->IsTranslucentWindowOpacitySupported();
 }
 
 void NativeAppWindowViews::SetVisibleOnAllWorkspaces(bool always_visible) {
   widget_->SetVisibleOnAllWorkspaces(always_visible);
 }
 
-}  // namespace apps
+}  // namespace extensions