Revert 251094 "Revert 250826 "Remove Profile dependency from app..."

trunk/src/apps/shell_window.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 "apps/shell_window.h"
 
 #include "apps/shell_window_geometry_cache.h"
 #include "apps/shell_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_web_contents_observer.h"
 #include "chrome/browser/extensions/suggest_permission_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/manifest_handlers/icons_handler.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/media_stream_request.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/extension.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/screen.h"
 
 #if !defined(OS_MACOSX)
 #include "apps/pref_names.h"
 #include "base/prefs/pref_service.h"
 #endif
 
+using content::BrowserContext;
 using content::ConsoleMessageLevel;
 using content::WebContents;
 using extensions::APIPermission;
 using web_modal::WebContentsModalDialogHost;
 using web_modal::WebContentsModalDialogManager;
 
 namespace {
 
 const int kDefaultWidth = 512;
 const int kDefaultHeight = 384;
@@ skipping 74 matching lines @@
     state(ui::SHOW_STATE_DEFAULT),
     hidden(false),
     resizable(true),
     focused(true),
     always_on_top(false) {}
 
 ShellWindow::CreateParams::~CreateParams() {}
 
 ShellWindow::Delegate::~Delegate() {}
 
-ShellWindow::ShellWindow(Profile* profile,
+ShellWindow::ShellWindow(BrowserContext* context,
                          Delegate* delegate,
                          const extensions::Extension* extension)
-    : profile_(profile),
+    : browser_context_(context),
       extension_(extension),
       extension_id_(extension->id()),
       window_type_(WINDOW_TYPE_DEFAULT),
       delegate_(delegate),
       image_loader_ptr_factory_(this),
       fullscreen_types_(FULLSCREEN_TYPE_NONE),
       show_on_first_paint_(false),
       first_paint_complete_(false),
       cached_always_on_top_(false) {
-  CHECK(!profile->IsGuestSession() || profile->IsOffTheRecord())
+  extensions::ExtensionsBrowserClient* client =
+      extensions::ExtensionsBrowserClient::Get();
+  CHECK(!client->IsGuestSession(context) || context->IsOffTheRecord())
       << "Only off the record window may be opened in the guest mode.";
 }
 
 void ShellWindow::Init(const GURL& url,
                        ShellWindowContents* shell_window_contents,
                        const CreateParams& params) {
   // Initialize the render interface and web contents
   shell_window_contents_.reset(shell_window_contents);
-  shell_window_contents_->Initialize(profile(), url);
+  shell_window_contents_->Initialize(browser_context(), url);
   WebContents* web_contents = shell_window_contents_->GetWebContents();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableAppsShowOnFirstPaint)) {
     content::WebContentsObserver::Observe(web_contents);
   }
   delegate_->InitWebContents(web_contents);
   WebContentsModalDialogManager::CreateForWebContents(web_contents);
   extensions::ExtensionWebContentsObserver::CreateForWebContents(web_contents);
 
   web_contents->SetDelegate(this);
@@ skipping 27 matching lines @@
     Maximize();
   else if (new_params.state == ui::SHOW_STATE_MINIMIZED)
     Minimize();
 
   OnNativeWindowChanged();
 
   // When the render view host is changed, the native window needs to know
   // about it in case it has any setup to do to make the renderer appear
   // properly. In particular, on Windows, the view's clickthrough region needs
   // to be set.
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(profile_->GetOriginalProfile()));
+  extensions::ExtensionsBrowserClient* client =
+      extensions::ExtensionsBrowserClient::Get();
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::Source<content::BrowserContext>(
+                     client->GetOriginalContext(browser_context_)));
   // Close when the browser process is exiting.
   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 
   shell_window_contents_->LoadContents(new_params.creator_process_id);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableAppsShowOnFirstPaint)) {
     // We want to show the window only when the content has been painted. For
     // that to happen, we need to define a size for the content, otherwise the
     // layout will happen in a 0x0 area.
     // Note: WebContents::GetView() is guaranteed to be non-null.
     web_contents->GetView()->SizeContents(new_params.bounds.size());
   }
 
   // Prevent the browser process from shutting down while this window is open.
   chrome::StartKeepAlive();
 
   UpdateExtensionAppIcon();
 
-  ShellWindowRegistry::Get(profile_)->AddShellWindow(this);
+  ShellWindowRegistry::Get(browser_context_)->AddShellWindow(this);
 }
 
 ShellWindow::~ShellWindow() {
   // Unregister now to prevent getting NOTIFICATION_APP_TERMINATING if we're the
   // last window open.
   registrar_.RemoveAll();
 
   // Remove shutdown prevention.
   chrome::EndKeepAlive();
 }
@@ skipping 22 matching lines @@
             params.url.spec().c_str()));
     return NULL;
   }
 
   // These dispositions aren't really navigations.
   if (disposition == SUPPRESS_OPEN || disposition == SAVE_TO_DISK ||
       disposition == IGNORE_ACTION) {
     return NULL;
   }
 
-  WebContents* contents = delegate_->OpenURLFromTab(profile_, source,
-                                                    params);
+  WebContents* contents =
+      delegate_->OpenURLFromTab(browser_context_, source, params);
   if (!contents) {
     AddMessageToDevToolsConsole(
         content::CONSOLE_MESSAGE_LEVEL_ERROR,
         base::StringPrintf(
             "Can't navigate to \"%s\"; apps do not support navigation.",
             params.url.spec().c_str()));
   }
 
   return contents;
 }
 
 void ShellWindow::AddNewContents(WebContents* source,
                                  WebContents* new_contents,
                                  WindowOpenDisposition disposition,
                                  const gfx::Rect& initial_pos,
                                  bool user_gesture,
                                  bool* was_blocked) {
-  DCHECK(Profile::FromBrowserContext(new_contents->GetBrowserContext()) ==
-      profile_);
-  delegate_->AddNewContents(profile_, new_contents, disposition,
-                            initial_pos, user_gesture, was_blocked);
+  DCHECK(new_contents->GetBrowserContext() == browser_context_);
+  delegate_->AddNewContents(browser_context_,
+                            new_contents,
+                            disposition,
+                            initial_pos,
+                            user_gesture,
+                            was_blocked);
 }
 
 bool ShellWindow::PreHandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   // Here, we can handle a key event before the content gets it. When we are
   // fullscreen and it is not forced, we want to allow the user to leave
   // when ESC is pressed.
   // However, if the application has the "overrideEscFullscreen" permission, we
@@ skipping 51 matching lines @@
 void ShellWindow::DidFirstVisuallyNonEmptyPaint(int32 page_id) {
   first_paint_complete_ = true;
   if (show_on_first_paint_) {
     DCHECK(delayed_show_type_ == SHOW_ACTIVE ||
            delayed_show_type_ == SHOW_INACTIVE);
     Show(delayed_show_type_);
   }
 }
 
 void ShellWindow::OnNativeClose() {
-  ShellWindowRegistry::Get(profile_)->RemoveShellWindow(this);
+  ShellWindowRegistry::Get(browser_context_)->RemoveShellWindow(this);
   if (shell_window_contents_) {
     WebContents* web_contents = shell_window_contents_->GetWebContents();
     WebContentsModalDialogManager::FromWebContents(web_contents)->
         SetDelegate(NULL);
     shell_window_contents_->NativeWindowClosed();
   }
   delete this;
 }
 
 void ShellWindow::OnNativeWindowChanged() {
   SaveWindowPosition();
 
 #if defined(OS_WIN)
   if (native_app_window_ &&
       cached_always_on_top_ &&
       !IsFullscreen(fullscreen_types_) &&
       !native_app_window_->IsMaximized() &&
       !native_app_window_->IsMinimized()) {
     UpdateNativeAlwaysOnTop();
   }
 #endif
 
   if (shell_window_contents_ && native_app_window_)
     shell_window_contents_->NativeWindowChanged(native_app_window_.get());
 }
 
 void ShellWindow::OnNativeWindowActivated() {
-  ShellWindowRegistry::Get(profile_)->ShellWindowActivated(this);
+  ShellWindowRegistry::Get(browser_context_)->ShellWindowActivated(this);
 }
 
 content::WebContents* ShellWindow::web_contents() const {
   return shell_window_contents_->GetWebContents();
 }
 
 NativeAppWindow* ShellWindow::GetBaseWindow() {
   return native_app_window_.get();
 }
 
@@ skipping 73 matching lines @@
 void ShellWindow::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
   native_app_window_->UpdateDraggableRegions(regions);
 }
 
 void ShellWindow::UpdateAppIcon(const gfx::Image& image) {
   if (image.IsEmpty())
     return;
   app_icon_ = image;
   native_app_window_->UpdateWindowIcon();
-  ShellWindowRegistry::Get(profile_)->ShellWindowIconChanged(this);
+  ShellWindowRegistry::Get(browser_context_)->ShellWindowIconChanged(this);
 }
 
 void ShellWindow::Fullscreen() {
 #if !defined(OS_MACOSX)
   // Do not enter fullscreen mode if disallowed by pref.
-  if (!profile()->GetPrefs()->GetBoolean(prefs::kAppFullscreenAllowed))
+  PrefService* prefs =
+      extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
+          browser_context());
+  if (!prefs->GetBoolean(prefs::kAppFullscreenAllowed))
     return;
 #endif
   fullscreen_types_ |= FULLSCREEN_TYPE_WINDOW_API;
   SetNativeWindowFullscreen();
 }
 
 void ShellWindow::Maximize() {
   GetBaseWindow()->Maximize();
 }
 
 void ShellWindow::Minimize() {
   GetBaseWindow()->Minimize();
 }
 
 void ShellWindow::Restore() {
   if (IsFullscreen(fullscreen_types_)) {
     fullscreen_types_ = FULLSCREEN_TYPE_NONE;
     SetNativeWindowFullscreen();
   } else {
     GetBaseWindow()->Restore();
   }
 }
 
 void ShellWindow::OSFullscreen() {
 #if !defined(OS_MACOSX)
   // Do not enter fullscreen mode if disallowed by pref.
-  if (!profile()->GetPrefs()->GetBoolean(prefs::kAppFullscreenAllowed))
+  PrefService* prefs =
+      extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
+          browser_context());
+  if (!prefs->GetBoolean(prefs::kAppFullscreenAllowed))
     return;
 #endif
   fullscreen_types_ |= FULLSCREEN_TYPE_OS;
   SetNativeWindowFullscreen();
 }
 
 void ShellWindow::ForcedFullscreen() {
   fullscreen_types_ |= FULLSCREEN_TYPE_FORCED;
   SetNativeWindowFullscreen();
 }
@@ skipping 125 matching lines @@
 void ShellWindow::OnExtensionIconImageChanged(extensions::IconImage* image) {
   DCHECK_EQ(app_icon_image_.get(), image);
 
   UpdateAppIcon(gfx::Image(app_icon_image_->image_skia()));
 }
 
 void ShellWindow::UpdateExtensionAppIcon() {
   // Avoid using any previous app icons were being downloaded.
   image_loader_ptr_factory_.InvalidateWeakPtrs();
 
-  app_icon_image_.reset(new extensions::IconImage(
-      profile(),
-      extension(),
-      extensions::IconsInfo::GetIcons(extension()),
-      delegate_->PreferredIconSize(),
-      extensions::IconsInfo::GetDefaultAppIcon(),
-      this));
+  app_icon_image_.reset(
+      new extensions::IconImage(browser_context(),
+                                extension(),
+                                extensions::IconsInfo::GetIcons(extension()),
+                                delegate_->PreferredIconSize(),
+                                extensions::IconsInfo::GetDefaultAppIcon(),
+                                this));
 
   // Triggers actual image loading with 1x resources. The 2x resource will
   // be handled by IconImage class when requested.
   app_icon_image_->image_skia().GetRepresentation(1.0f);
 }
 
 void ShellWindow::OnSizeConstraintsChanged() {
   native_app_window_->UpdateWindowMinMaxSize();
   gfx::Rect bounds = GetClientBounds();
   gfx::Size constrained_size = size_constraints_.ClampSize(bounds.size());
@@ skipping 92 matching lines @@
   else if (changed_flags & content::INVALIDATE_TYPE_TAB)
     native_app_window_->UpdateWindowIcon();
 }
 
 void ShellWindow::ToggleFullscreenModeForTab(content::WebContents* source,
                                              bool enter_fullscreen) {
 #if !defined(OS_MACOSX)
   // Do not enter fullscreen mode if disallowed by pref.
   // TODO(bartfab): Add a test once it becomes possible to simulate a user
   // gesture. http://crbug.com/174178
-  if (enter_fullscreen &&
-      !profile()->GetPrefs()->GetBoolean(prefs::kAppFullscreenAllowed)) {
+  PrefService* prefs =
+      extensions::ExtensionsBrowserClient::Get()->GetPrefServiceForContext(
+          browser_context());
+  if (enter_fullscreen && !prefs->GetBoolean(prefs::kAppFullscreenAllowed)) {
     return;
   }
 #endif
 
   if (!IsExtensionWithPermissionOrSuggestInConsole(
       APIPermission::kFullscreen,
       extension_,
       source->GetRenderViewHost())) {
     return;
   }
@@ skipping 55 matching lines @@
   rvh->Send(new ExtensionMsg_AddMessageToConsole(
       rvh->GetRoutingID(), level, message));
 }
 
 void ShellWindow::SaveWindowPosition() {
   if (window_key_.empty())
     return;
   if (!native_app_window_)
     return;
 
-  ShellWindowGeometryCache* cache = ShellWindowGeometryCache::Get(profile());
+  ShellWindowGeometryCache* cache =
+      ShellWindowGeometryCache::Get(browser_context());
 
   gfx::Rect bounds = native_app_window_->GetRestoredBounds();
   bounds.Inset(native_app_window_->GetFrameInsets());
   gfx::Rect screen_bounds =
       gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds).work_area();
   ui::WindowShowState window_state = native_app_window_->GetRestoredState();
   cache->SaveGeometry(extension()->id(),
                       window_key_,
                       bounds,
                       screen_bounds,
@@ skipping 35 matching lines @@
   if (params.bounds.width() == 0)
     params.bounds.set_width(kDefaultWidth);
   if (params.bounds.height() == 0)
     params.bounds.set_height(kDefaultHeight);
 
   // If left and top are left undefined, the native shell window will center
   // the window on the main screen in a platform-defined manner.
 
   // Load cached state if it exists.
   if (!params.window_key.empty()) {
-    ShellWindowGeometryCache* cache = ShellWindowGeometryCache::Get(profile());
+    ShellWindowGeometryCache* cache =
+        ShellWindowGeometryCache::Get(browser_context());
 
     gfx::Rect cached_bounds;
     gfx::Rect cached_screen_bounds;
     ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
     if (cache->GetGeometry(extension()->id(), params.window_key,
                            &cached_bounds, &cached_screen_bounds,
                            &cached_state)) {
       // App window has cached screen bounds, make sure it fits on screen in
       // case the screen resolution changed.
       gfx::Screen* screen = gfx::Screen::GetNativeScreen();
@@ skipping 28 matching lines @@
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }
 
 }  // namespace apps