Add frame color option to packaged app windows.

chrome/browser/ui/views/apps/native_app_window_views.cc

 // Copyright 2013 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 "chrome/browser/ui/views/apps/native_app_window_views.h"
 
 #include "apps/app_window.h"
 #include "apps/ui/views/app_window_frame_view.h"
 #include "base/command_line.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 193 matching lines @@
     : web_view_(NULL),
       window_(NULL),
       is_fullscreen_(false),
       weak_ptr_factory_(this) {
 }
 
 void NativeAppWindowViews::Init(apps::AppWindow* app_window,
                                 const AppWindow::CreateParams& create_params) {
   app_window_ = app_window;
   frameless_ = create_params.frame == AppWindow::FRAME_NONE;
+  has_frame_color_ = create_params.has_frame_color;
+  frame_color_ = create_params.frame_color;
   transparent_background_ = create_params.transparent_background;
   resizable_ = create_params.resizable;
   Observe(web_contents());
 
   window_ = new views::Widget;
   if (create_params.window_type == AppWindow::WINDOW_TYPE_PANEL ||
       create_params.window_type == AppWindow::WINDOW_TYPE_V1_PANEL) {
     InitializePanelWindow(create_params);
   } else {
     InitializeDefaultWindow(create_params);
   }
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryViews(
       Profile::FromBrowserContext(browser_context()),
       window_->GetFocusManager(),
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
       app_window_));
 
   OnViewWasResized();
   window_->AddObserver(this);
 
 #if defined(OS_WIN)
-  if (ShouldUseChromeStyleFrame() &&
+  if (ShouldUseNativeFrame() &&
       chrome::GetHostDesktopTypeForNativeWindow(window_->GetNativeWindow()) !=
       chrome::HOST_DESKTOP_TYPE_ASH) {
     InstallEasyResizeTargeterOnContainer();
   }
 #endif
 }
 
 NativeAppWindowViews::~NativeAppWindowViews() {
   web_view_->SetWebContents(NULL);
 }
 
 void NativeAppWindowViews::OnBeforeWidgetInit(
     views::Widget::InitParams* init_params,
     views::Widget* widget) {}
 
 void NativeAppWindowViews::InitializeDefaultWindow(
     const AppWindow::CreateParams& create_params) {
   std::string app_name =
       web_app::GenerateApplicationNameFromExtensionId(extension()->id());
 
   views::Widget::InitParams init_params(views::Widget::InitParams::TYPE_WINDOW);
   init_params.delegate = this;
-  init_params.remove_standard_frame = ShouldUseChromeStyleFrame();
+  init_params.remove_standard_frame = !ShouldUseNativeFrame();
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // On Linux, remove the standard frame. Instead, we will use CustomFrameView
   // to draw a native-like frame.
   // TODO(mgiuca): Remove this during fix for http://crbug.com/322256.
   init_params.remove_standard_frame = true;
 #endif
   init_params.use_system_default_icon = true;
   // TODO(erg): Conceptually, these are toplevel windows, but we theoretically
   // could plumb context through to here in some cases.
   init_params.top_level = true;
@@ skipping 100 matching lines @@
                                           native_window->GetRootWindow(),
                                           native_window->GetBoundsInScreen());
     window_->SetBounds(window_bounds);
   }
 #else
   // TODO(stevenjb): NativeAppWindow panels need to be implemented for other
   // platforms.
 #endif
 }
 
-bool NativeAppWindowViews::ShouldUseChromeStyleFrame() const {
-  if (frameless_)
-    return true;
-
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-  // Linux always uses native style frames.
-  return false;
-#endif
-
-  return !CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kAppsUseNativeFrame);
+bool NativeAppWindowViews::ShouldUseNativeFrame() const {
+  return !frameless_ & !has_frame_color_;
 }
 
 void NativeAppWindowViews::InstallEasyResizeTargeterOnContainer() const {
   aura::Window* root_window = window_->GetNativeWindow()->GetRootWindow();
   gfx::Insets inset(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
                     kResizeInsideBoundsSize, kResizeInsideBoundsSize);
   root_window->SetEventTargeter(scoped_ptr<ui::EventTargeter>(
       new wm::EasyResizeWindowTargeter(root_window, inset, inset)));
 }
 
 apps::AppWindowFrameView* NativeAppWindowViews::CreateAppWindowFrameView() {
   // By default the user can resize the window from slightly inside the bounds.
   int resize_inside_bounds_size = kResizeInsideBoundsSize;
   int resize_outside_bounds_size = 0;
   int resize_outside_scale_for_touch = 1;
   int resize_area_corner_size = kResizeAreaCornerSize;
 #if defined(USE_ASH)
   // For Aura windows on the Ash desktop the sizes are different and the user
   // can resize the window from slightly outside the bounds as well.
   if (chrome::IsNativeWindowInAsh(window_->GetNativeWindow())) {
     resize_inside_bounds_size = ash::kResizeInsideBoundsSize;
     resize_outside_bounds_size = ash::kResizeOutsideBoundsSize;
     resize_outside_scale_for_touch = ash::kResizeOutsideBoundsScaleForTouch;
     resize_area_corner_size = ash::kResizeAreaCornerSize;
   }
 #endif
   apps::AppWindowFrameView* frame_view = new apps::AppWindowFrameView(this);
   frame_view->Init(window_,
+                   frame_color_,
                    resize_inside_bounds_size,
                    resize_outside_bounds_size,
                    resize_outside_scale_for_touch,
                    resize_area_corner_size);
   return frame_view;
 }
 
 // ui::BaseWindow implementation.
 
 bool NativeAppWindowViews::IsActive() const {
@@ skipping 203 matching lines @@
 bool NativeAppWindowViews::CanResize() const {
   return resizable_ && !app_window_->size_constraints().HasFixedSize();
 }
 
 bool NativeAppWindowViews::CanMaximize() const {
   return resizable_ && !app_window_->size_constraints().HasMaximumSize() &&
          !app_window_->window_type_is_panel();
 }
 
 base::string16 NativeAppWindowViews::GetWindowTitle() const {
-  return app_window_->GetTitle();
+  return base::string16();
 }
 
 bool NativeAppWindowViews::ShouldShowWindowTitle() const {
   return app_window_->window_type() == AppWindow::WINDOW_TYPE_V1_PANEL;
 }
 
 gfx::ImageSkia NativeAppWindowViews::GetWindowAppIcon() {
   gfx::Image app_icon = app_window_->app_icon();
   if (app_icon.IsEmpty())
     return GetWindowIcon();
@@ skipping 71 matching lines @@
             new ash::ImmersiveFullscreenController());
         custom_frame_view->InitImmersiveFullscreenControllerForView(
             immersive_fullscreen_controller_.get());
       }
 #endif
       custom_frame_view->GetHeaderView()->set_context_menu_controller(this);
       return custom_frame_view;
     }
   }
 #endif
-  if (ShouldUseChromeStyleFrame())
+  if (!ShouldUseNativeFrame())
     return CreateAppWindowFrameView();
   return views::WidgetDelegateView::CreateNonClientFrameView(widget);
 }
 
 bool NativeAppWindowViews::WidgetHasHitTestMask() const {
   return shape_ != NULL;
 }
 
 void NativeAppWindowViews::GetWidgetHitTestMask(gfx::Path* mask) const {
   shape_->getBoundaryPath(mask);
@@ skipping 221 matching lines @@
 void NativeAppWindowViews::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   unhandled_keyboard_event_handler_.HandleKeyboardEvent(event,
                                                         GetFocusManager());
 }
 
 bool NativeAppWindowViews::IsFrameless() const {
   return frameless_;
 }
 
+bool NativeAppWindowViews::HasFrameColor() const { return has_frame_color_; }
+
+SkColor NativeAppWindowViews::FrameColor() const { return frame_color_; }
+
 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 =
       window_->non_client_view()->GetWindowBoundsForClientBounds(
           client_bounds);
   return window_bounds.InsetsFrom(client_bounds);
 }
 
 void NativeAppWindowViews::HideWithApp() {}
 void NativeAppWindowViews::ShowWithApp() {}
 void NativeAppWindowViews::UpdateWindowMinMaxSize() {}