Rename ShellWindow* classes

chrome/browser/ui/extensions/shell_window.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 "chrome/browser/ui/extensions/shell_window.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/shell_window_geometry_cache.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/intents/web_intents_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
-#include "chrome/browser/ui/extensions/native_shell_window.h"
+#include "chrome/browser/ui/extensions/native_app_window.h"
 #include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/api/app_window.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/request_media_access_permission_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/invalidate_type.h"
@@ skipping 100 matching lines @@
           shell_window_geometry_cache();
     gfx::Rect cached_bounds;
     if (cache->GetGeometry(extension()->id(), params.window_key,
                            &cached_bounds))
       bounds = cached_bounds;
   }
 
   ShellWindow::CreateParams new_params = params;
   new_params.bounds = bounds;
 
-  native_window_.reset(NativeShellWindow::Create(this, new_params));
+  native_app_window_.reset(NativeAppWindow::Create(this, new_params));
   OnNativeWindowChanged();
 
   if (!params.hidden)
     GetBaseWindow()->Show();
 
   // If the new view is in the same process as the creator, block the created
   // RVH from loading anything until the background page has had a chance to do
   // any initialization it wants. If it's a different process, the new RVH
   // shouldn't communicate with the background page anyway (e.g. sandboxed).
   if (web_contents_->GetRenderViewHost()->GetProcess()->GetID() ==
@@ skipping 114 matching lines @@
   disposition =
       disposition == NEW_BACKGROUND_TAB ? disposition : NEW_FOREGROUND_TAB;
   chrome::AddWebContents(browser, NULL, new_contents, disposition, initial_pos,
                          user_gesture, was_blocked);
 }
 
 void ShellWindow::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   DCHECK_EQ(source, web_contents_);
-  native_window_->HandleKeyboardEvent(event);
+  native_app_window_->HandleKeyboardEvent(event);
 }
 
 void ShellWindow::OnNativeClose() {
   extensions::ShellWindowRegistry::Get(profile_)->RemoveShellWindow(this);
   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   rvh->Send(new ExtensionMsg_AppWindowClosed(rvh->GetRoutingID()));
   delete this;
 }
 
 void ShellWindow::OnNativeWindowChanged() {
   SaveWindowPosition();
-  if (!native_window_ || !web_contents_)
+  if (!native_app_window_ || !web_contents_)
     return;
   ListValue args;
   DictionaryValue* dictionary = new DictionaryValue();
   args.Append(dictionary);
 
-  gfx::Rect bounds = native_window_->GetBounds();
+  gfx::Rect bounds = native_app_window_->GetBounds();
   app_window::Bounds update;
   update.left.reset(new int(bounds.x()));
   update.top.reset(new int(bounds.y()));
   update.width.reset(new int(bounds.width()));
   update.height.reset(new int(bounds.height()));
   dictionary->Set("bounds", update.ToValue().release());
-  dictionary->SetBoolean("minimized", native_window_->IsMinimized());
-  dictionary->SetBoolean("maximized", native_window_->IsMaximized());
+  dictionary->SetBoolean("minimized", native_app_window_->IsMinimized());
+  dictionary->SetBoolean("maximized", native_app_window_->IsMaximized());
 
   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   rvh->Send(new ExtensionMsg_MessageInvoke(rvh->GetRoutingID(),
                                            extension_->id(),
                                            "updateAppWindowProperties",
                                            args,
                                            GURL(),
                                            false));
 }
 
 
 BaseWindow* ShellWindow::GetBaseWindow() {
-  return native_window_.get();
+  return native_app_window_.get();
 }
 
 string16 ShellWindow::GetTitle() const {
   // WebContents::GetTitle() will return the page's URL if there's no <title>
   // specified. However, we'd prefer to show the name of the extension in that
   // case, so we directly inspect the NavigationEntry's title.
   if (!web_contents()->GetController().GetActiveEntry() ||
       web_contents()->GetController().GetActiveEntry()->GetTitle().empty())
     return UTF8ToUTF16(extension()->name());
   string16 title = web_contents()->GetTitle();
   Browser::FormatTitleForDisplay(&title);
   return title;
 }
 
 bool ShellWindow::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ShellWindow, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_UpdateDraggableRegions,
                         UpdateDraggableRegions)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ShellWindow::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
-  native_window_->UpdateDraggableRegions(regions);
+  native_app_window_->UpdateDraggableRegions(regions);
 }
 
 void ShellWindow::OnImageLoaded(const gfx::Image& image,
                                 const std::string& extension_id,
                                 int index) {
   if (!image.IsEmpty()) {
     app_icon_ = image;
-    native_window_->UpdateWindowIcon();
+    native_app_window_->UpdateWindowIcon();
   }
   app_icon_loader_.reset();
 }
 
 void ShellWindow::UpdateExtensionAppIcon() {
   app_icon_loader_.reset(new ImageLoadingTracker(this));
   app_icon_loader_->LoadImage(
       extension(),
       extension()->GetIconResource(extension_misc::EXTENSION_ICON_SMALL,
                                    ExtensionIconSet::MATCH_BIGGER),
       gfx::Size(extension_misc::EXTENSION_ICON_SMALL,
                 extension_misc::EXTENSION_ICON_SMALL),
       ImageLoadingTracker::CACHE);
 }
 
 void ShellWindow::CloseContents(WebContents* contents) {
   DCHECK(contents == web_contents_);
-  native_window_->Close();
+  native_app_window_->Close();
 }
 
 bool ShellWindow::ShouldSuppressDialogs() {
   return true;
 }
 
 void ShellWindow::WebIntentDispatch(
     content::WebContents* web_contents,
     content::WebIntentsDispatcher* intents_dispatcher) {
   if (!web_intents::IsWebIntentsEnabledForProfile(profile_))
@@ skipping 12 matching lines @@
   FileSelectHelper::RunFileChooser(tab, params);
 }
 
 bool ShellWindow::IsPopupOrPanel(const WebContents* source) const {
   DCHECK(source == web_contents_.get());
   return true;
 }
 
 void ShellWindow::MoveContents(WebContents* source, const gfx::Rect& pos) {
   DCHECK(source == web_contents_.get());
-  native_window_->SetBounds(pos);
+  native_app_window_->SetBounds(pos);
 }
 
 void ShellWindow::NavigationStateChanged(
     const content::WebContents* source, unsigned changed_flags) {
   DCHECK(source == web_contents_.get());
   if (changed_flags & content::INVALIDATE_TYPE_TITLE)
-    native_window_->UpdateWindowTitle();
+    native_app_window_->UpdateWindowTitle();
   else if (changed_flags & content::INVALIDATE_TYPE_TAB)
-    native_window_->UpdateWindowIcon();
+    native_app_window_->UpdateWindowIcon();
 }
 
 void ShellWindow::ToggleFullscreenModeForTab(content::WebContents* source,
                                              bool enter_fullscreen) {
   DCHECK(source == web_contents_.get());
-  native_window_->SetFullscreen(enter_fullscreen);
+  native_app_window_->SetFullscreen(enter_fullscreen);
 }
 
 bool ShellWindow::IsFullscreenForTabOrPending(
     const content::WebContents* source) const {
   DCHECK(source == web_contents_.get());
-  return native_window_->IsFullscreenOrPending();
+  return native_app_window_->IsFullscreenOrPending();
 }
 
 void ShellWindow::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
       // TODO(jeremya): once http://crbug.com/123007 is fixed, we'll no longer
       // need to suspend resource requests here (the call in the constructor
       // should be enough).
       content::Details<std::pair<RenderViewHost*, RenderViewHost*> >
           host_details(details);
       if (host_details->first)
         SuspendRenderViewHost(host_details->second);
       // TODO(jianli): once http://crbug.com/123007 is fixed, we'll no longer
       // need to make the native window (ShellWindowViews specially) update
       // the clickthrough region for the new RVH.
-      native_window_->RenderViewHostChanged();
+      native_app_window_->RenderViewHostChanged();
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const extensions::Extension* unloaded_extension =
           content::Details<extensions::UnloadedExtensionInfo>(
               details)->extension;
       if (extension_ == unloaded_extension)
-        native_window_->Close();
+        native_app_window_->Close();
       break;
     }
     case chrome::NOTIFICATION_APP_TERMINATING:
-      native_window_->Close();
+      native_app_window_->Close();
       break;
     default:
       NOTREACHED() << "Received unexpected notification";
   }
 }
 
 extensions::WindowController*
 ShellWindow::GetExtensionWindowController() const {
   return NULL;
 }
@@ skipping 17 matching lines @@
                                               const std::string& message) {
   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   rvh->Send(new ExtensionMsg_AddMessageToConsole(
       rvh->GetRoutingID(), level, message));
 }
 
 
 void ShellWindow::SaveWindowPosition() {
   if (window_key_.empty())
     return;
-  if (!native_window_)
+  if (!native_app_window_)
     return;
 
   extensions::ShellWindowGeometryCache* cache =
       extensions::ExtensionSystem::Get(profile())->
           shell_window_geometry_cache();
 
-  gfx::Rect bounds = native_window_->GetBounds();
+  gfx::Rect bounds = native_app_window_->GetBounds();
   cache->SaveGeometry(extension()->id(), window_key_, bounds);
 }
 
 // static
 SkRegion* ShellWindow::RawDraggableRegionsToSkRegion(
       const std::vector<extensions::DraggableRegion>& regions) {
   SkRegion* sk_region = new SkRegion;
   for (std::vector<extensions::DraggableRegion>::const_iterator iter =
            regions.begin();
        iter != regions.end(); ++iter) {
     const extensions::DraggableRegion& region = *iter;
     sk_region->op(
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }