Remove NPAPI support from Chrome Frame.

chrome_frame/chrome_frame_automation.cc

 // Copyright (c) 2011 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_frame/chrome_frame_automation.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 20 matching lines @@
 #include "chrome_frame/simple_resource_loader.h"
 #include "chrome_frame/utils.h"
 #include "ui/base/ui_base_switches.h"
 
 #ifdef NDEBUG
 int64 kAutomationServerReasonableLaunchDelay = 1000;  // in milliseconds
 #else
 int64 kAutomationServerReasonableLaunchDelay = 1000 * 10;
 #endif
 
-int kDefaultSendUMADataInterval = 20000;  // in milliseconds.
-
-static const wchar_t kUmaSendIntervalValue[] = L"UmaSendInterval";
-
 class ChromeFrameAutomationProxyImpl::TabProxyNotificationMessageFilter
     : public IPC::ChannelProxy::MessageFilter {
  public:
   explicit TabProxyNotificationMessageFilter(AutomationHandleTracker* tracker)
       : tracker_(tracker) {
   }
 
   void AddTabProxy(AutomationHandle tab_proxy) {
     base::AutoLock lock(lock_);
     tabs_list_.push_back(tab_proxy);
@@ skipping 143 matching lines @@
 #else
   void Dump() {}
 #endif
 };
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(AutomationProxyCacheEntry);
 
 AutomationProxyCacheEntry::AutomationProxyCacheEntry(
     ChromeFrameLaunchParams* params, LaunchDelegate* delegate)
     : profile_name(params->profile_name()),
-      launch_result_(AUTOMATION_LAUNCH_RESULT_INVALID),
-      snapshots_(NULL), uma_send_interval_(1) {
+      launch_result_(AUTOMATION_LAUNCH_RESULT_INVALID) {
   DCHECK(delegate);
   thread_.reset(new base::Thread(WideToASCII(profile_name).c_str()));
   thread_->Start();
   // Use scoped_refptr so that the params will get released when the task
   // has been run.
   scoped_refptr<ChromeFrameLaunchParams> ref_params(params);
   thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
       &AutomationProxyCacheEntry::CreateProxy, ref_params, delegate));
 }
 
 AutomationProxyCacheEntry::~AutomationProxyCacheEntry() {
   DVLOG(1) << __FUNCTION__ << profile_name;
   // Attempt to fix chrome_frame_tests crash seen at times on the IE6/IE7
   // builders. It appears that there are cases when we can enter here when the
   // AtExitManager is tearing down the global ProxyCache which causes a crash
   // while tearing down the AutomationProxy object due to a NULL MessageLoop
   // The AutomationProxy class uses the SyncChannel which assumes the existence
   // of a MessageLoop instance.
   // We leak the AutomationProxy pointer here to avoid a crash.
   if (MessageLoop::current() == NULL) {
     proxy_.release();
   }
 }
 
-void AutomationProxyCacheEntry::StartSendUmaInterval(
-    ChromeFrameHistogramSnapshots* snapshots, int send_interval) {
-  DCHECK(snapshots);
-  DCHECK(!snapshots_);
-  snapshots_ = snapshots;
-  uma_send_interval_ = send_interval;
-  thread_->message_loop()->PostDelayedTask(FROM_HERE,
-      NewRunnableMethod(this, &AutomationProxyCacheEntry::SendUMAData),
-      send_interval);
-}
-
 void AutomationProxyCacheEntry::CreateProxy(ChromeFrameLaunchParams* params,
                                             LaunchDelegate* delegate) {
   DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   DCHECK(delegate);
   DCHECK(params);
   DCHECK(proxy_.get() == NULL);
 
   // We *must* create automationproxy in a thread that has message loop,
   // since SyncChannel::Context construction registers event to be watched
   // through ObjectWatcher which subscribes for the current thread message loop
@@ skipping 119 matching lines @@
   *was_last_delegate = false;
 
   LaunchDelegates::iterator it = std::find(launch_delegates_.begin(),
       launch_delegates_.end(), delegate);
   if (it == launch_delegates_.end()) {
     NOTREACHED();
   } else {
     if (launch_delegates_.size() == 1) {
       *was_last_delegate = true;
 
-      if (snapshots_)
-        SendUMAData();
-
       // Process pending notifications.
       thread_->message_loop()->RunAllPending();
 
       // Take down the proxy since we no longer have any clients.
       // Make sure we only do this once all pending messages have been cleared.
       proxy_.reset(NULL);
     }
     // Be careful to remove from the list after running pending
     // tasks.  Otherwise the delegate being removed might miss out
     // on pending notifications such as LaunchComplete.
@@ skipping 17 matching lines @@
 
 void AutomationProxyCacheEntry::OnChannelError() {
   DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
   launch_result_ = AUTOMATION_SERVER_CRASHED;
   LaunchDelegates::const_iterator it = launch_delegates_.begin();
   for (; it != launch_delegates_.end(); ++it) {
     (*it)->AutomationServerDied();
   }
 }
 
-void AutomationProxyCacheEntry::SendUMAData() {
-  DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
-  DCHECK(snapshots_);
-  // IE uses the chrome frame provided UMA data uploading scheme. NPAPI
-  // continues to use Chrome to upload UMA data.
-  if (CrashMetricsReporter::GetInstance()->active()) {
-    return;
-  }
-
-  if (!proxy_.get()) {
-    DLOG(WARNING) << __FUNCTION__ << " NULL proxy, can't send UMA data";
-  } else {
-    ChromeFrameHistogramSnapshots::HistogramPickledList histograms =
-        snapshots_->GatherAllHistograms();
-
-    if (!histograms.empty()) {
-      proxy_->Send(new AutomationMsg_RecordHistograms(histograms));
-    }
-
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        NewRunnableMethod(this, &AutomationProxyCacheEntry::SendUMAData),
-        uma_send_interval_);
-  }
-}
-
-
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ProxyFactory);
 
-ProxyFactory::ProxyFactory()
-    : uma_send_interval_(0) {
-  uma_send_interval_ = GetConfigInt(kDefaultSendUMADataInterval,
-                                    kUmaSendIntervalValue);
+ProxyFactory::ProxyFactory() {
 }
 
 ProxyFactory::~ProxyFactory() {
   for (size_t i = 0; i < proxies_.container().size(); ++i) {
     DWORD result = proxies_[i]->WaitForThread(0);
     if (WAIT_OBJECT_0 != result)
       // TODO(stoyan): Don't leak proxies on exit.
       DLOG(ERROR) << "Proxies leaked on exit.";
   }
 }
@@ skipping 10 matching lines @@
     if (proxies_[i]->IsSameProfile(params->profile_name())) {
       entry = proxies_[i];
       break;
     }
   }
 
   if (entry == NULL) {
     DVLOG(1) << __FUNCTION__ << " creating new proxy entry";
     entry = new AutomationProxyCacheEntry(params, delegate);
     proxies_.container().push_back(entry);
-
-    // IE uses the chrome frame provided UMA data uploading scheme. NPAPI
-    // continues to use Chrome to upload UMA data.
-    if (!CrashMetricsReporter::GetInstance()->active()) {
-      entry->StartSendUmaInterval(&chrome_frame_histograms_,
-                                  uma_send_interval_);
-    }
   } else if (delegate) {
     // Notify the new delegate of the launch status from the worker thread
     // and add it to the list of delegates.
     entry->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(entry.get(),
         &AutomationProxyCacheEntry::AddDelegate, delegate));
   }
 
   DCHECK(automation_server_id != NULL);
   DCHECK(!entry->IsSameThread(base::PlatformThread::CurrentId()));
 
@@ skipping 111 matching lines @@
     DCHECK_LT(chrome_launch_params_->launch_timeout(),
               MAXINT / 2000);
     chrome_launch_params_->set_launch_timeout(
         chrome_launch_params_->launch_timeout() * 2);
   }
 #endif  // NDEBUG
 
   // Create a window on the UI thread for marshaling messages back and forth
   // from the IPC thread. This window cannot be a message only window as the
   // external chrome tab window is created as a child of this window. This
-  // window is eventually reparented to the ActiveX/NPAPI plugin window.
+  // window is eventually reparented to the ActiveX plugin window.
   if (!Create(GetDesktopWindow(), NULL, NULL,
               WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
               WS_EX_TOOLWINDOW)) {
     NOTREACHED();
     return false;
   }
 
   // Keep object in memory, while the window is alive.
   // Corresponding Release is in OnFinalMessage();
   AddRef();
@@ skipping 15 matching lines @@
 
 void ChromeFrameAutomationClient::Uninitialize() {
   if (init_state_ == UNINITIALIZED) {
     DLOG(WARNING) << __FUNCTION__ << ": Automation client not initialized";
     return;
   }
 
   init_state_ = UNINITIALIZING;
 
   // Called from client's FinalRelease() / destructor
-  // ChromeFrameAutomationClient may wait for the initialization (launch)
-  // to complete while Uninitialize is called.
-  // We either have to:
-  // 1) Make ReleaseAutomationServer blocking call (wait until thread exits)
-  // 2) Behave like a COM object i.e. increase module lock count.
-  // Otherwise the DLL may get unloaded while we have running threads.
-  // Unfortunately in NPAPI case we cannot increase module lock count, hence
-  // we stick with blocking/waiting
   if (url_fetcher_) {
     // Clean up any outstanding requests
     url_fetcher_->StopAllRequests();
     url_fetcher_ = NULL;
   }
 
   if (tab_) {
     tab_->RemoveObserver(this);
     if (automation_server_)
       automation_server_->ReleaseTabProxy(tab_->handle());
@@ skipping 372 matching lines @@
       }
       break;
   }
 
   PostTask(FROM_HERE, NewRunnableMethod(this,
       &ChromeFrameAutomationClient::ProcessUrlRequestMessage, tab, msg, true));
   return true;
 }
 
 // These are invoked in channel's background thread.
-// Cannot call any method of the activex/npapi here since they are STA
-// kind of beings.
+// Cannot call any method of the activex here since it is a STA kind of being.
 // By default we marshal the IPC message to the main/GUI thread and from there
 // we safely invoke chrome_frame_delegate_->OnMessageReceived(msg).
 bool ChromeFrameAutomationClient::OnMessageReceived(TabProxy* tab,
                                                     const IPC::Message& msg) {
   DCHECK(tab == tab_.get());
   // Quickly process network related messages.
   if (url_fetcher_ && ProcessUrlRequestMessage(tab, msg, false))
     return true;
 
   // Early check to avoid needless marshaling
@@ skipping 279 matching lines @@
     const net::URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(
       tab_->handle(), request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
   automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(
       tab_->handle(), success, url, cookie_string, cookie_id));
 }