Rename apps::ShellWindow to apps::AppWindow

chrome/browser/ui/gtk/apps/native_app_window_gtk.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/gtk/apps/native_app_window_gtk.h"
 
 #include <gdk/gdkx.h>
 #include <vector>
 
 #include "base/message_loop/message_pump_gtk.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/gtk/extensions/extension_keybinding_registry_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/gtk_window_util.h"
 #include "chrome/browser/web_applications/web_app.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 "content/public/browser/web_contents_view.h"
 #include "extensions/common/extension.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.h"
 
-using apps::ShellWindow;
+using apps::AppWindow;
 
 namespace {
 
 // The timeout in milliseconds before we'll get the true window position with
 // gtk_window_get_position() after the last GTK configure-event signal.
 const int kDebounceTimeoutMilliseconds = 100;
 
 const char* kAtomsToCache[] = {
   "_NET_WM_STATE",
   "_NET_WM_STATE_HIDDEN",
   NULL
 };
 
 } // namespace
 
-NativeAppWindowGtk::NativeAppWindowGtk(ShellWindow* shell_window,
-                                       const ShellWindow::CreateParams& params)
-    : shell_window_(shell_window),
+NativeAppWindowGtk::NativeAppWindowGtk(AppWindow* app_window,
+                                       const AppWindow::CreateParams& params)
+    : app_window_(app_window),
       window_(NULL),
       state_(GDK_WINDOW_STATE_WITHDRAWN),
       is_active_(false),
       content_thinks_its_fullscreen_(false),
       maximize_pending_(false),
-      frameless_(params.frame == ShellWindow::FRAME_NONE),
+      frameless_(params.frame == AppWindow::FRAME_NONE),
       always_on_top_(params.always_on_top),
       frame_cursor_(NULL),
       atom_cache_(base::MessagePumpGtk::GetDefaultXDisplay(), kAtomsToCache),
       is_x_event_listened_(false) {
   Observe(web_contents());
 
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 
   gfx::NativeView native_view =
       web_contents()->GetView()->GetNativeView();
@@ skipping 20 matching lines @@
     gtk_window_set_resizable(window_, FALSE);
   }
 
   // make sure bounds_ and restored_bounds_ have correct values until we
   // get our first configure-event
   bounds_ = restored_bounds_ = params.bounds;
   gint x, y;
   gtk_window_get_position(window_, &x, &y);
   bounds_.set_origin(gfx::Point(x, y));
 
-  // Hide titlebar when {frame: 'none'} specified on ShellWindow.
+  // Hide titlebar when {frame: 'none'} specified on AppWindow..
   if (frameless_)
     gtk_window_set_decorated(window_, false);
 
   if (always_on_top_)
     gtk_window_set_keep_above(window_, TRUE);
 
   UpdateWindowMinMaxSize();
 
   // In some (older) versions of compiz, raising top-level windows when they
   // are partially off-screen causes them to get snapped back on screen, not
@@ skipping 36 matching lines @@
       GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(window_));
       gdk_window_add_filter(window,
                             &NativeAppWindowGtk::OnXEventThunk,
                             this);
       is_x_event_listened_ = true;
     }
   }
 
   // Add the keybinding registry.
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryGtk(
-      Profile::FromBrowserContext(shell_window_->browser_context()),
+      Profile::FromBrowserContext(app_window_->browser_context()),
       window_,
       extensions::ExtensionKeybindingRegistry::PLATFORM_APPS_ONLY,
-      shell_window_));
+      app_window_));
 
   ui::ActiveWindowWatcherX::AddObserver(this);
 }
 
 NativeAppWindowGtk::~NativeAppWindowGtk() {
   ui::ActiveWindowWatcherX::RemoveObserver(this);
   if (is_x_event_listened_) {
     gdk_window_remove_filter(NULL,
                              &NativeAppWindowGtk::OnXEventThunk,
                              this);
@@ skipping 61 matching lines @@
 void NativeAppWindowGtk::ShowInactive() {
   gtk_window_set_focus_on_map(window_, false);
   gtk_widget_show(GTK_WIDGET(window_));
 }
 
 void NativeAppWindowGtk::Hide() {
   gtk_widget_hide(GTK_WIDGET(window_));
 }
 
 void NativeAppWindowGtk::Close() {
-  shell_window_->OnNativeWindowChanged();
+  app_window_->OnNativeWindowChanged();
 
   // Cancel any pending callback from the window configure debounce timer.
   window_configure_debounce_timer_.Stop();
 
   GtkWidget* window = GTK_WIDGET(window_);
   // To help catch bugs in any event handlers that might get fired during the
   // destruction, set window_ to NULL before any handlers will run.
   window_ = NULL;
 
   // OnNativeClose does a delete this so no other members should
   // be accessed after. gtk_widget_destroy is safe (and must
   // be last).
-  shell_window_->OnNativeClose();
+  app_window_->OnNativeClose();
   gtk_widget_destroy(window);
 }
 
 void NativeAppWindowGtk::Activate() {
   gtk_window_present(window_);
 }
 
 void NativeAppWindowGtk::Deactivate() {
   gdk_window_lower(gtk_widget_get_window(GTK_WIDGET(window_)));
 }
@@ skipping 70 matching lines @@
     std::vector< ::Atom>::iterator it =
         std::find(atom_list.begin(),
                   atom_list.end(),
                   atom_cache_.GetAtom("_NET_WM_STATE_HIDDEN"));
 
     GdkWindowState previous_state = state_;
     state_ = (it != atom_list.end()) ? GDK_WINDOW_STATE_ICONIFIED :
         static_cast<GdkWindowState>(state_ & ~GDK_WINDOW_STATE_ICONIFIED);
 
     if (previous_state != state_) {
-      shell_window_->OnNativeWindowChanged();
+      app_window_->OnNativeWindowChanged();
     }
   }
 
   return GDK_FILTER_CONTINUE;
 }
 
 void NativeAppWindowGtk::FlashFrame(bool flash) {
   gtk_window_set_urgency_hint(window_, flash);
 }
 
@@ skipping 46 matching lines @@
   observer_list_.RemoveObserver(observer);
 }
 
 void NativeAppWindowGtk::ActiveWindowChanged(GdkWindow* active_window) {
   // Do nothing if we're in the process of closing the browser window.
   if (!window_)
     return;
 
   is_active_ = gtk_widget_get_window(GTK_WIDGET(window_)) == active_window;
   if (is_active_)
-    shell_window_->OnNativeWindowActivated();
+    app_window_->OnNativeWindowActivated();
 }
 
 // Callback for the delete event.  This event is fired when the user tries to
 // close the window (e.g., clicking on the X in the window manager title bar).
 gboolean NativeAppWindowGtk::OnMainWindowDeleteEvent(GtkWidget* widget,
                                                      GdkEvent* event) {
   Close();
 
   // Return true to prevent the GTK window from being destroyed.  Close will
   // destroy it for us.
@@ skipping 22 matching lines @@
   window_configure_debounce_timer_.Stop();
   window_configure_debounce_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds), this,
       &NativeAppWindowGtk::OnConfigureDebounced);
 
   return FALSE;
 }
 
 void NativeAppWindowGtk::OnConfigureDebounced() {
   gtk_window_util::UpdateWindowPosition(this, &bounds_, &restored_bounds_);
-  shell_window_->OnNativeWindowChanged();
+  app_window_->OnNativeWindowChanged();
 
   FOR_EACH_OBSERVER(web_modal::ModalDialogHostObserver,
                     observer_list_,
                     OnPositionRequiresUpdate());
 
   // Fullscreen of non-resizable windows requires them to be made resizable
   // first. After that takes effect and OnConfigure is called we transition
   // to fullscreen.
   if (!IsFullscreen() && IsFullscreenOrPending()) {
     gtk_window_fullscreen(window_);
@@ skipping 127 matching lines @@
       gdk_window_lower(gdk_window);
     return TRUE;
   }
 
   return FALSE;
 }
 
 // NativeAppWindow implementation:
 
 void NativeAppWindowGtk::SetFullscreen(int fullscreen_types) {
-  bool fullscreen = (fullscreen_types != ShellWindow::FULLSCREEN_TYPE_NONE);
+  bool fullscreen = (fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
   content_thinks_its_fullscreen_ = fullscreen;
   if (fullscreen) {
     if (resizable_) {
       gtk_window_fullscreen(window_);
     } else {
       // We must first make the window resizable. That won't take effect
       // immediately, so OnConfigureDebounced completes the fullscreen call.
       gtk_window_set_resizable(window_, TRUE);
     }
   } else {
@@ skipping 11 matching lines @@
   // will fall back to |IsFullscreen| which will soon have the correct state.
   return content_thinks_its_fullscreen_ || IsFullscreen();
 }
 
 bool NativeAppWindowGtk::IsDetached() const {
   return false;
 }
 
 void NativeAppWindowGtk::UpdateWindowIcon() {
   Profile* profile =
-      Profile::FromBrowserContext(shell_window_->browser_context());
-  gfx::Image app_icon = shell_window_->app_icon();
+      Profile::FromBrowserContext(app_window_->browser_context());
+  gfx::Image app_icon = app_window_->app_icon();
   if (!app_icon.IsEmpty())
     gtk_util::SetWindowIcon(window_, profile, app_icon.ToGdkPixbuf());
   else
     gtk_util::SetWindowIcon(window_, profile);
 }
 
 void NativeAppWindowGtk::UpdateWindowTitle() {
-  base::string16 title = shell_window_->GetTitle();
+  base::string16 title = app_window_->GetTitle();
   gtk_window_set_title(window_, base::UTF16ToUTF8(title).c_str());
 }
 
 void NativeAppWindowGtk::UpdateBadgeIcon() {
   NOTIMPLEMENTED();
 }
 
 void NativeAppWindowGtk::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
   if (!frameless_)
     return;
 
-  draggable_region_.reset(ShellWindow::RawDraggableRegionsToSkRegion(regions));
+  draggable_region_.reset(AppWindow::RawDraggableRegionsToSkRegion(regions));
 }
 
 SkRegion* NativeAppWindowGtk::GetDraggableRegion() {
   return draggable_region_.get();
 }
 
 void NativeAppWindowGtk::UpdateShape(scoped_ptr<SkRegion> region) {
   NOTIMPLEMENTED();
 }
 
@@ skipping 31 matching lines @@
       rect_with_decorations.height - current_height - top_inset,
       rect_with_decorations.width - current_width - left_inset);
 }
 
 void NativeAppWindowGtk::HideWithApp() {}
 void NativeAppWindowGtk::ShowWithApp() {}
 
 void NativeAppWindowGtk::UpdateWindowMinMaxSize() {
   GdkGeometry hints;
   int hints_mask = 0;
-  if (shell_window_->size_constraints().HasMinimumSize()) {
-    gfx::Size min_size = shell_window_->size_constraints().GetMinimumSize();
+  if (app_window_->size_constraints().HasMinimumSize()) {
+    gfx::Size min_size = app_window_->size_constraints().GetMinimumSize();
     hints.min_height = min_size.height();
     hints.min_width = min_size.width();
     hints_mask |= GDK_HINT_MIN_SIZE;
   }
-  if (shell_window_->size_constraints().HasMaximumSize()) {
-    gfx::Size max_size = shell_window_->size_constraints().GetMaximumSize();
-    const int kUnboundedSize = ShellWindow::SizeConstraints::kUnboundedSize;
+  if (app_window_->size_constraints().HasMaximumSize()) {
+    gfx::Size max_size = app_window_->size_constraints().GetMaximumSize();
+    const int kUnboundedSize = AppWindow::SizeConstraints::kUnboundedSize;
     hints.max_height = max_size.height() == kUnboundedSize ?
         G_MAXINT : max_size.height();
     hints.max_width = max_size.width() == kUnboundedSize ?
         G_MAXINT : max_size.width();
     hints_mask |= GDK_HINT_MAX_SIZE;
   }
   if (hints_mask) {
     gtk_window_set_geometry_hints(
         window_,
         GTK_WIDGET(window_),
         &hints,
         static_cast<GdkWindowHints>(hints_mask));
   }
 }