Remove code to defer app window appearance until first paint.

extensions/browser/app_window/app_window.cc

 // Copyright 2014 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 "extensions/browser/app_window/app_window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
-#include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.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/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"
-#include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
 #include "extensions/browser/app_window/app_delegate.h"
 #include "extensions/browser/app_window/app_web_contents_helper.h"
 #include "extensions/browser/app_window/app_window_client.h"
 #include "extensions/browser/app_window/app_window_geometry_cache.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/app_window/size_constraints.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_web_contents_observer.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/suggest_permission_util.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/draggable_region.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "extensions/common/permissions/permissions_data.h"
-#include "extensions/common/switches.h"
 #include "extensions/grit/extensions_browser_resources.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/image/image_skia_operations.h"
 
 #if !defined(OS_MACOSX)
 #include "components/prefs/pref_service.h"
@@ skipping 176 matching lines @@
 // AppWindow
 
 AppWindow::AppWindow(BrowserContext* context,
                      AppDelegate* app_delegate,
                      const Extension* extension)
     : browser_context_(context),
       extension_id_(extension->id()),
       window_type_(WINDOW_TYPE_DEFAULT),
       app_delegate_(app_delegate),
       fullscreen_types_(FULLSCREEN_TYPE_NONE),
-      show_on_first_paint_(false),
-      first_paint_complete_(false),
       has_been_shown_(false),
-      can_send_events_(false),
       is_hidden_(false),
-      delayed_show_type_(SHOW_ACTIVE),
       cached_always_on_top_(false),
       requested_alpha_enabled_(false),
       is_ime_window_(false),
       show_in_shelf_(false),
       image_loader_ptr_factory_(this) {
   ExtensionsBrowserClient* client = ExtensionsBrowserClient::Get();
   CHECK(!client->IsGuestSession(context) || context->IsOffTheRecord())
       << "Only off the record window may be opened in the guest mode.";
 }
 
@@ skipping 78 matching lines @@
   OnNativeWindowChanged();
 
   ExtensionRegistry::Get(browser_context_)->AddObserver(this);
 
   // Close when the browser process is exiting.
   app_delegate_->SetTerminatingCallback(
       base::Bind(&NativeAppWindow::Close,
                  base::Unretained(native_app_window_.get())));
 
   app_window_contents_->LoadContents(new_params.creator_process_id);
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          extensions::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.
-    gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
-    gfx::Rect initial_bounds = new_params.GetInitialWindowBounds(frame_insets);
-    initial_bounds.Inset(frame_insets);
-    app_delegate_->ResizeWebContents(web_contents(), initial_bounds.size());
-  }
 }
 
 AppWindow::~AppWindow() {
   ExtensionRegistry::Get(browser_context_)->RemoveObserver(this);
 }
 
 void AppWindow::RequestMediaAccessPermission(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
@@ skipping 87 matching lines @@
     content::RenderFrameHost* frame,
     const content::BluetoothChooser::EventHandler& event_handler) {
   return ExtensionsBrowserClient::Get()->CreateBluetoothChooser(frame,
                                                                 event_handler);
 }
 
 void AppWindow::RenderViewCreated(content::RenderViewHost* render_view_host) {
   app_delegate_->RenderViewCreated(render_view_host);
 }
 
-void AppWindow::DidFirstVisuallyNonEmptyPaint() {
-  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 AppWindow::SetOnFirstCommitCallback(const base::Closure& callback) {
   DCHECK(on_first_commit_callback_.is_null());
   on_first_commit_callback_ = callback;
 }
 
 void AppWindow::OnReadyToCommitFirstNavigation() {
   if (!content::IsBrowserSideNavigationEnabled())
     return;
 
   // PlzNavigate: execute renderer-side setup now that there is a renderer
   // process assigned to the navigation. With renderer-side navigation, this
   // would happen before the navigation starts, but PlzNavigate must wait until
   // this point in time in the navigation.
 
-  WindowEventsReady();
   if (on_first_commit_callback_.is_null())
     return;
   // It is important that the callback executes after the calls to
   // WebContentsObserver::ReadyToCommitNavigation have been processed. The
   // CommitNavigation IPC that will properly set up the renderer will only be
   // sent after these, and it must be sent before the callback gets to run,
   // hence the use of PostTask.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::ResetAndReturn(&on_first_commit_callback_));
 }
@@ skipping 212 matching lines @@
     native_app_window_->SetBounds(bounds);
   }
   OnNativeWindowChanged();
 }
 
 void AppWindow::Show(ShowType show_type) {
   app_delegate_->OnShow();
   bool was_hidden = is_hidden_ || !has_been_shown_;
   is_hidden_ = false;
 
-  if (base::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;
   }
   AppWindowRegistry::Get(browser_context_)->AppWindowShown(this, was_hidden);
-
   has_been_shown_ = true;
-  SendOnWindowShownIfShown();
 }
 
 void AppWindow::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.
   is_hidden_ = true;
-  show_on_first_paint_ = false;
   GetBaseWindow()->Hide();
   AppWindowRegistry::Get(browser_context_)->AppWindowHidden(this);
   app_delegate_->OnHide();
 }
 
 void AppWindow::SetAlwaysOnTop(bool always_on_top) {
   if (cached_always_on_top_ == always_on_top)
     return;
 
   cached_always_on_top_ = always_on_top;
 
   // As a security measure, do not allow fullscreen windows or windows that
   // overlap the taskbar to be on top. The property will be applied when the
   // window exits fullscreen and moves away from the taskbar.
   if (!IsFullscreen() && !IntersectsWithTaskbar())
     native_app_window_->SetAlwaysOnTop(always_on_top);
 
   OnNativeWindowChanged();
 }
 
 bool AppWindow::IsAlwaysOnTop() const { return cached_always_on_top_; }
 
 void AppWindow::RestoreAlwaysOnTop() {
   if (cached_always_on_top_)
     UpdateNativeAlwaysOnTop();
 }
 
-void AppWindow::WindowEventsReady() {
-  can_send_events_ = true;
-  SendOnWindowShownIfShown();
-}
-
 void AppWindow::NotifyRenderViewReady() {
   if (app_window_contents_)
     app_window_contents_->OnWindowReady();
 }
 
 void AppWindow::GetSerializedState(base::DictionaryValue* properties) const {
   DCHECK(properties);
 
   properties->SetBoolean("fullscreen",
                          native_app_window_->IsFullscreenOrPending());
@@ skipping 131 matching lines @@
     // When entering fullscreen or overlapping the taskbar, ensure windows are
     // not always-on-top.
     native_app_window_->SetAlwaysOnTop(false);
   } else if (!is_on_top && !fullscreen && !intersects_taskbar) {
     // When exiting fullscreen and moving away from the taskbar, reinstate
     // always-on-top.
     native_app_window_->SetAlwaysOnTop(true);
   }
 }
 
-void AppWindow::SendOnWindowShownIfShown() {
-  if (!can_send_events_ || !has_been_shown_)
-    return;
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          ::switches::kTestType)) {
-    app_window_contents_->DispatchWindowShownForTests();
-  }
-}
-
 void AppWindow::CloseContents(WebContents* contents) {
   native_app_window_->Close();
 }
 
 bool AppWindow::ShouldSuppressDialogs(WebContents* source) {
   return true;
 }
 
 content::ColorChooser* AppWindow::OpenColorChooser(
     WebContents* web_contents,
@@ skipping 200 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 extensions