Defer app window appearance until first paint.

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_process_manager.h"
 #include "chrome/browser/extensions/extension_system.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.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/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/view_type_utils.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
 
@@ skipping 89 matching lines @@
 ShellWindow::ShellWindow(Profile* profile,
                          Delegate* delegate,
                          const extensions::Extension* extension)
     : profile_(profile),
       extension_(extension),
       extension_id_(extension->id()),
       window_type_(WINDOW_TYPE_DEFAULT),
       delegate_(delegate),
       image_loader_ptr_factory_(this),
       fullscreen_for_window_api_(false),
-      fullscreen_for_tab_(false) {
+      fullscreen_for_tab_(false),
+      show_on_first_paint_(false),
+      first_paint_complete_(false) {
 }
 
 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);
   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);
   WebContentsModalDialogManager::FromWebContents(web_contents)->
       SetDelegate(this);
   extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_SHELL);
 
   // Initialize the window
   CreateParams new_params = LoadDefaultsAndConstrain(params);
   window_type_ = new_params.window_type;
   window_key_ = new_params.window_key;
   size_constraints_ = SizeConstraints(new_params.minimum_size,
                                       new_params.maximum_size);
   native_app_window_.reset(delegate_->CreateNativeAppWindow(this, new_params));
 
   if (!new_params.hidden) {
-    if (window_type_is_panel())
-      GetBaseWindow()->ShowInactive();  // Panels are not activated by default.
-    else
-      GetBaseWindow()->Show();
+    // Panels are not activated by default.
+    Show(window_type_is_panel() ? SHOW_INACTIVE : SHOW_ACTIVE);
   }
 
   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
     Fullscreen();
   else if (new_params.state == ui::SHOW_STATE_MAXIMIZED)
     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_));
   // 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);
 }
 
 ShellWindow::~ShellWindow() {
   // Unregister now to prevent getting NOTIFICATION_APP_TERMINATING if we're the
@@ skipping 70 matching lines @@
                                      bool user_gesture,
                                      bool last_unlocked_by_target) {
   bool has_permission = IsExtensionWithPermissionOrSuggestInConsole(
       APIPermission::kPointerLock,
       extension_,
       web_contents->GetRenderViewHost());
 
   web_contents->GotResponseToLockMouseRequest(has_permission);
 }
 
+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);
   if (shell_window_contents_) {
     WebContents* web_contents = shell_window_contents_->GetWebContents();
     WebContentsModalDialogManager::FromWebContents(web_contents)->
         SetDelegate(NULL);
     shell_window_contents_->NativeWindowClosed();
   }
   delete this;
 }
@@ skipping 107 matching lines @@
 void ShellWindow::SetMinimumSize(const gfx::Size& min_size) {
   size_constraints_.set_minimum_size(min_size);
   OnSizeConstraintsChanged();
 }
 
 void ShellWindow::SetMaximumSize(const gfx::Size& max_size) {
   size_constraints_.set_maximum_size(max_size);
   OnSizeConstraintsChanged();
 }
 
+void ShellWindow::Show(ShowType show_type) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kEnableAppsShowOnFirstPaint)) {
+    show_on_first_paint_ = true;
+
+    if (!first_paint_complete_) {
+      delayed_show_type_ = show_type;
+      return;
+    }
+  }
+
+  switch (show_type) {
+    case SHOW_ACTIVE:
+      GetBaseWindow()->Show();
+      break;
+    case SHOW_INACTIVE:
+      GetBaseWindow()->ShowInactive();
+      break;
+  }
+}
+
+void ShellWindow::Hide() {
+  // This is there to prevent race conditions with Hide() being called before
+  // there was a non-empty paint. It should have no effect in a non-racy
+  // scenario where the application is hiding then showing a window: the second
+  // show will not be delayed.
+  show_on_first_paint_ = false;
+  GetBaseWindow()->Hide();
+}
+
 //------------------------------------------------------------------------------
 // Private methods
 
 void ShellWindow::DidDownloadFavicon(
     int id,
     int http_status_code,
     const GURL& image_url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_bitmap_sizes) {
   if (image_url != app_icon_url_ || bitmaps.empty())
@@ skipping 270 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