Remove NPAPI support from Chrome Frame.

chrome_frame/chrome_frame_automation.h

 // 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.
 
 #ifndef CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_
 #define CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_
 
 #include <atlbase.h>
 #include <atlwin.h>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_handle.h"
 #include "base/stack_container.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome_frame/chrome_frame_delegate.h"
-#include "chrome_frame/chrome_frame_histograms.h"
 #include "chrome_frame/plugin_url_request.h"
 #include "chrome_frame/sync_msg_reply_dispatcher.h"
 #include "content/common/page_zoom.h"
 
 // By a convoluated route, this timeout also winds up being the sync automation
 // message timeout. See the ChromeFrameAutomationProxyImpl ctor and the
 // AutomationProxy ctor for details.
 const unsigned long kCommandExecutionTimeout = 60000;  // NOLINT, 60 seconds
 
 class ProxyFactory;
@@ skipping 189 matching lines @@
  public:
   AutomationProxyCacheEntry(ChromeFrameLaunchParams* params,
                             LaunchDelegate* delegate);
 
   ~AutomationProxyCacheEntry();
 
   void AddDelegate(LaunchDelegate* delegate);
   void RemoveDelegate(LaunchDelegate* delegate, base::WaitableEvent* done,
                       bool* was_last_delegate);
 
-  void StartSendUmaInterval(ChromeFrameHistogramSnapshots* snapshots,
-                            int send_interval);
-
   DWORD WaitForThread(DWORD timeout) {  // NOLINT
     DCHECK(thread_.get());
     return ::WaitForSingleObject(thread_->thread_handle(), timeout);
   }
 
   bool IsSameProfile(const std::wstring& name) const {
     return lstrcmpiW(name.c_str(), profile_name.c_str()) == 0;
   }
 
   base::Thread* thread() const {
@@ skipping 12 matching lines @@
     DCHECK(IsSameThread(base::PlatformThread::CurrentId()));
     return proxy_.get();
   }
 
   // Called by the proxy when the automation server has unexpectedly gone away.
   void OnChannelError();
 
  protected:
   void CreateProxy(ChromeFrameLaunchParams* params,
                    LaunchDelegate* delegate);
-  void SendUMAData();
 
  protected:
   std::wstring profile_name;
   scoped_ptr<base::Thread> thread_;
   scoped_ptr<ChromeFrameAutomationProxyImpl> proxy_;
   AutomationLaunchResult launch_result_;
   typedef std::vector<LaunchDelegate*> LaunchDelegates;
   LaunchDelegates launch_delegates_;
   // Used for UMA histogram logging to measure the time for the chrome
   // automation server to start;
   base::TimeTicks automation_server_launch_start_time_;
-  ChromeFrameHistogramSnapshots* snapshots_;
-  int uma_send_interval_;
 };
 
 // We must create and destroy automation proxy in a thread with a message loop.
 // Hence thread cannot be a member of the proxy.
 class ProxyFactory {
  public:
   ProxyFactory();
   virtual ~ProxyFactory();
 
   // Fetches or creates a new automation server instance.
   // delegate may be NULL.  If non-null, a pointer to the delegate will
   // be stored for the lifetime of the automation process or until
   // ReleaseAutomationServer is called.
   virtual void GetAutomationServer(LaunchDelegate* delegate,
                                    ChromeFrameLaunchParams* params,
                                    void** automation_server_id);
   virtual bool ReleaseAutomationServer(void* server_id,
                                        LaunchDelegate* delegate);
 
  private:
   typedef StackVector<scoped_refptr<AutomationProxyCacheEntry>, 4> Vector;
   Vector proxies_;
   // Lock if we are going to call GetAutomationServer from more than one thread.
   base::Lock lock_;
-
-  // Gathers histograms to be sent to Chrome.
-  ChromeFrameHistogramSnapshots chrome_frame_histograms_;
-
-  // Interval for sending UMA data
-  int uma_send_interval_;
 };
 
 // Handles all automation requests initiated from the chrome frame objects.
-// These include the chrome tab/chrome frame activex/chrome frame npapi
-// plugin objects.
+// These include the chrome tab/chrome frame activex plugin objects.
 class ChromeFrameAutomationClient
     : public CWindowImpl<ChromeFrameAutomationClient>,
       public TaskMarshallerThroughWindowsMessages<ChromeFrameAutomationClient>,
       public base::RefCountedThreadSafe<ChromeFrameAutomationClient>,
       public PluginUrlRequestDelegate,
       public TabProxy::TabProxyDelegate,
       public LaunchDelegate {
  public:
   ChromeFrameAutomationClient();
   ~ChromeFrameAutomationClient();
@@ skipping 210 matching lines @@
   // set to true if the host needs to get notified of all top level navigations
   // in this page. This typically applies to hosts which would render the new
   // page without chrome frame. Defaults to false.
   bool route_all_top_level_navigations_;
 
   friend class BeginNavigateContext;
   friend class CreateExternalTabContext;
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_