Add instrumentation to help tracking issue 638400.

content/renderer/render_frame_impl.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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1058 matching lines @@
       media_player_delegate_(NULL),
       is_using_lofi_(false),
       effective_connection_type_(
           blink::WebEffectiveConnectionType::TypeUnknown),
       is_pasting_(false),
       suppress_further_dialogs_(false),
       blame_context_(nullptr),
 #if defined(ENABLE_PLUGINS)
       focused_pepper_plugin_(nullptr),
       pepper_last_mouse_event_target_(nullptr),
+      plugin_creation_state_(CreatePluginState::NONE),
 #endif
       frame_binding_(this),
       has_accessed_initial_document_(false),
       weak_factory_(this) {
   // We don't have a shell::Connection at this point, so use nullptr.
   // TODO(beng): We should fix this, so we can apply policy about which
   //             interfaces get exposed.
   interface_registry_.reset(new shell::InterfaceRegistry);
   shell::mojom::InterfaceProviderPtr remote_interfaces;
   pending_remote_interface_provider_request_ = GetProxy(&remote_interfaces);
@@ skipping 18 matching lines @@
 
 #if defined(ENABLE_PLUGINS)
   // Manages its own lifetime.
   plugin_power_saver_helper_ = new PluginPowerSaverHelper(this);
 #endif
 
   manifest_manager_ = new ManifestManager(this);
 }
 
 RenderFrameImpl::~RenderFrameImpl() {
+#if defined(ENABLE_PLUGINS)
+  if (plugin_creation_state_ == CreatePluginState::UNINITIALIZED)
+    base::debug::DumpWithoutCrashing();
+#endif
+
   // If file chooser is still waiting for answer, dispatch empty answer.
   while (!file_chooser_completions_.empty()) {
     if (file_chooser_completions_.front()->completion) {
       file_chooser_completions_.front()->completion->didChooseFile(
           WebVector<WebString>());
     }
     file_chooser_completions_.pop_front();
   }
 
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, RenderFrameGone());
@@ skipping 1215 matching lines @@
 void RenderFrameImpl::CancelContextMenu(int request_id) {
   DCHECK(pending_context_menus_.Lookup(request_id));
   pending_context_menus_.Remove(request_id);
 }
 
 blink::WebPlugin* RenderFrameImpl::CreatePlugin(
     blink::WebFrame* frame,
     const WebPluginInfo& info,
     const blink::WebPluginParams& params,
     std::unique_ptr<content::PluginInstanceThrottler> throttler) {
-  DCHECK_EQ(frame_, frame);
+  CHECK_EQ(frame_, frame);
 #if defined(ENABLE_PLUGINS)
   if (info.type == WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN) {
     return BrowserPluginManager::Get()->CreateBrowserPlugin(
         this, GetContentClient()
                   ->renderer()
                   ->CreateBrowserPluginDelegate(this, params.mimeType.utf8(),
                                                 GURL(params.url))
                   ->GetWeakPtr());
   }
 
   bool pepper_plugin_was_registered = false;
   scoped_refptr<PluginModule> pepper_module(PluginModule::Create(
       this, info, &pepper_plugin_was_registered));
   if (pepper_plugin_was_registered) {
     if (pepper_module.get()) {
+      plugin_creation_state_ = CreatePluginState::UNINITIALIZED;
       return new PepperWebPluginImpl(
           pepper_module.get(), params, this,
           base::WrapUnique(
               static_cast<PluginInstanceThrottlerImpl*>(throttler.release())));
     }
   }
 #if defined(OS_CHROMEOS)
   LOG(WARNING) << "Pepper module/plugin creation failed.";
 #endif
 #endif
@@ skipping 133 matching lines @@
 void RenderFrameImpl::GetInterfaceProvider(
     shell::mojom::InterfaceProviderRequest request) {
   interface_registry_->Bind(std::move(request));
 }
 
 // blink::WebFrameClient implementation ----------------------------------------
 
 blink::WebPlugin* RenderFrameImpl::createPlugin(
     blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params) {
-  DCHECK_EQ(frame_, frame);
+  CHECK_EQ(frame_, frame);
   blink::WebPlugin* plugin = NULL;
   if (GetContentClient()->renderer()->OverrideCreatePlugin(
           this, frame, params, &plugin)) {
     return plugin;
   }
 
   if (base::UTF16ToUTF8(base::StringPiece16(params.mimeType)) ==
       kBrowserPluginMimeType) {
     return BrowserPluginManager::Get()->CreateBrowserPlugin(
         this, GetContentClient()
@@ skipping 3699 matching lines @@
                                    request_id,
                                    match_count,
                                    selection_rect,
                                    ordinal,
                                    final_status_update));
 }
 
 #if defined(ENABLE_PLUGINS)
 void RenderFrameImpl::PepperInstanceCreated(
     PepperPluginInstanceImpl* instance) {
+  plugin_creation_state_ = CreatePluginState::NONE;

[Charlie Reis, 2016/09/02 20:04:10]

Is there a reason for this to be an enum?  Seems like a is_plugin_initializing_
bool might be clearer, if we don't need to support more states.  (It's a bit
unexpected to go back to NONE here rather than something like INITIALIZED, until
you realize there's only two states.)

[lfg, 2016/09/02 20:28:00]

Yes, initially I had 3 states, unitialized, initializing, initialized, but then
I realized I didn't need this. The bool makes more sense, changed.

   active_pepper_instances_.insert(instance);
 
   Send(new FrameHostMsg_PepperInstanceCreated(
       routing_id_, instance->pp_instance()));
 }
 
 void RenderFrameImpl::PepperInstanceDeleted(
     PepperPluginInstanceImpl* instance) {
   active_pepper_instances_.erase(instance);
 
@@ skipping 68 matching lines @@
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content