Rename ChromeShellWindowDelegate to ChromeAppWindowDelegate

chrome/browser/ui/apps/chrome_app_window_delegate.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/apps/chrome_shell_window_delegate.h"
+#include "chrome/browser/ui/apps/chrome_app_window_delegate.h"
 
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
@@ skipping 75 matching lines @@
 
   virtual bool IsOwnedByWorker() OVERRIDE { return true; }
 
  private:
   content::WebContents* source_;
   const content::OpenURLParams params_;
 };
 
 }  // namespace
 
-ShellWindowLinkDelegate::ShellWindowLinkDelegate() {}
+AppWindowLinkDelegate::AppWindowLinkDelegate() {}
 
-ShellWindowLinkDelegate::~ShellWindowLinkDelegate() {}
+AppWindowLinkDelegate::~AppWindowLinkDelegate() {}
 
 // TODO(rockot): Add a test that exercises this code. See
 // http://crbug.com/254260.
-content::WebContents* ShellWindowLinkDelegate::OpenURLFromTab(
+content::WebContents* AppWindowLinkDelegate::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {
   if (source) {
     scoped_refptr<ShellIntegration::DefaultWebClientWorker>
         check_if_default_browser_worker =
             new ShellIntegration::DefaultBrowserWorker(
                 new OpenURLFromTabBasedOnBrowserDefault(source, params));
     // Object lifetime notes: The OpenURLFromTabBasedOnBrowserDefault is owned
     // by check_if_default_browser_worker. StartCheckIsDefault() takes lifetime
     // ownership of check_if_default_browser_worker and will clean up after
     // the asynchronous tasks.
     check_if_default_browser_worker->StartCheckIsDefault();
   }
   return NULL;
 }
 
-ChromeShellWindowDelegate::ChromeShellWindowDelegate() {}
+ChromeAppWindowDelegate::ChromeAppWindowDelegate() {}
 
-ChromeShellWindowDelegate::~ChromeShellWindowDelegate() {}
+ChromeAppWindowDelegate::~ChromeAppWindowDelegate() {}
 
-void ChromeShellWindowDelegate::DisableExternalOpenForTesting() {
+void ChromeAppWindowDelegate::DisableExternalOpenForTesting() {
   disable_external_open_for_testing_ = true;
 }
 
-void ChromeShellWindowDelegate::InitWebContents(
+void ChromeAppWindowDelegate::InitWebContents(
     content::WebContents* web_contents) {
   FaviconTabHelper::CreateForWebContents(web_contents);
 
 #if defined(ENABLE_PRINTING)
 #if defined(ENABLE_FULL_PRINTING)
   printing::PrintViewManager::CreateForWebContents(web_contents);
   printing::PrintPreviewMessageHandler::CreateForWebContents(web_contents);
 #else
   printing::PrintViewManagerBasic::CreateForWebContents(web_contents);
 #endif  // defined(ENABLE_FULL_PRINTING)
 #endif  // defined(ENABLE_PRINTING)
 }
 
-apps::NativeAppWindow* ChromeShellWindowDelegate::CreateNativeAppWindow(
+apps::NativeAppWindow* ChromeAppWindowDelegate::CreateNativeAppWindow(
     apps::AppWindow* window,
     const apps::AppWindow::CreateParams& params) {
   return CreateNativeAppWindowImpl(window, params);
 }
 
-content::WebContents* ChromeShellWindowDelegate::OpenURLFromTab(
+content::WebContents* ChromeAppWindowDelegate::OpenURLFromTab(
     content::BrowserContext* context,
     content::WebContents* source,
     const content::OpenURLParams& params) {
   return OpenURLFromTabInternal(context, source, params);
 }
 
-void ChromeShellWindowDelegate::AddNewContents(
-    content::BrowserContext* context,
-    content::WebContents* new_contents,
-    WindowOpenDisposition disposition,
-    const gfx::Rect& initial_pos,
-    bool user_gesture,
-    bool* was_blocked) {
+void ChromeAppWindowDelegate::AddNewContents(content::BrowserContext* context,
+                                             content::WebContents* new_contents,
+                                             WindowOpenDisposition disposition,
+                                             const gfx::Rect& initial_pos,
+                                             bool user_gesture,
+                                             bool* was_blocked) {
   if (!disable_external_open_for_testing_) {
-    if (!shell_window_link_delegate_.get())
-      shell_window_link_delegate_.reset(new ShellWindowLinkDelegate());
-    new_contents->SetDelegate(shell_window_link_delegate_.get());
+    if (!app_window_link_delegate_.get())
+      app_window_link_delegate_.reset(new AppWindowLinkDelegate());
+    new_contents->SetDelegate(app_window_link_delegate_.get());
     return;
   }
   chrome::ScopedTabbedBrowserDisplayer displayer(
       Profile::FromBrowserContext(context), chrome::GetActiveDesktop());
   // Force all links to open in a new tab, even if they were trying to open a
   // new window.
   disposition =
       disposition == NEW_BACKGROUND_TAB ? disposition : NEW_FOREGROUND_TAB;
   chrome::AddWebContents(displayer.browser(), NULL, new_contents, disposition,
                          initial_pos, user_gesture, was_blocked);
 }
 
-content::ColorChooser* ChromeShellWindowDelegate::ShowColorChooser(
+content::ColorChooser* ChromeAppWindowDelegate::ShowColorChooser(
     content::WebContents* web_contents,
     SkColor initial_color) {
   return chrome::ShowColorChooser(web_contents, initial_color);
 }
 
-void ChromeShellWindowDelegate::RunFileChooser(
+void ChromeAppWindowDelegate::RunFileChooser(
     content::WebContents* tab,
     const content::FileChooserParams& params) {
   FileSelectHelper::RunFileChooser(tab, params);
 }
 
-void ChromeShellWindowDelegate::RequestMediaAccessPermission(
-      content::WebContents* web_contents,
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback,
-      const extensions::Extension* extension) {
+void ChromeAppWindowDelegate::RequestMediaAccessPermission(
+    content::WebContents* web_contents,
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback,
+    const extensions::Extension* extension) {
   MediaCaptureDevicesDispatcher::GetInstance()->ProcessMediaAccessRequest(
       web_contents, request, callback, extension);
 }
 
-int ChromeShellWindowDelegate::PreferredIconSize() {
+int ChromeAppWindowDelegate::PreferredIconSize() {
 #if defined(USE_ASH)
   return ash::kShelfPreferredSize;
 #else
   return extension_misc::EXTENSION_ICON_SMALL;
 #endif
 }
 
-void ChromeShellWindowDelegate::SetWebContentsBlocked(
+void ChromeAppWindowDelegate::SetWebContentsBlocked(
     content::WebContents* web_contents,
     bool blocked) {
   // RenderViewHost may be NULL during shutdown.
   content::RenderViewHost* host = web_contents->GetRenderViewHost();
   if (host) {
     host->Send(new ChromeViewMsg_SetVisuallyDeemphasized(
         host->GetRoutingID(), blocked));
   }
 }
 
-bool ChromeShellWindowDelegate::IsWebContentsVisible(
+bool ChromeAppWindowDelegate::IsWebContentsVisible(
     content::WebContents* web_contents) {
   return platform_util::IsVisible(web_contents->GetView()->GetNativeView());
 }