Revert "Allow MessageFilters to restrict listening to specific message classes"

content/public/browser/browser_message_filter.h

 // Copyright (c) 2012 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 CONTENT_PUBLIC_BROWSER_BROWSER_MESSAGE_FILTER_H_
 #define CONTENT_PUBLIC_BROWSER_BROWSER_MESSAGE_FILTER_H_
 
 #include "base/memory/ref_counted.h"
 #include "base/process/process.h"
 #include "content/common/content_export.h"
@@ skipping 11 matching lines @@
 namespace content {
 struct BrowserMessageFilterTraits;
 
 // Base class for message filters in the browser process.  You can receive and
 // send messages on any thread.
 class CONTENT_EXPORT BrowserMessageFilter
     : public base::RefCountedThreadSafe<
           BrowserMessageFilter, BrowserMessageFilterTraits>,
       public IPC::Sender {
  public:
-  explicit BrowserMessageFilter(uint32 message_class_to_filter);
-  BrowserMessageFilter(const uint32* message_classes_to_filter,
-                       size_t num_message_classes_to_filter);
+  BrowserMessageFilter();
 
   // These match the corresponding IPC::ChannelProxy::MessageFilter methods and
   // are always called on the IO thread.
   virtual void OnFilterAdded(IPC::Channel* channel) {}
   virtual void OnFilterRemoved() {}
   virtual void OnChannelClosing() {}
   virtual void OnChannelConnected(int32 peer_pid) {}
 
   // Called when the message filter is about to be deleted.  This gives
   // derived classes the option of controlling which thread they're deleted
@@ skipping 41 matching lines @@
 
   // Checks that the given message can be dispatched on the UI thread, depending
   // on the platform.  If not, returns false and an error ot the sender.
   static bool CheckCanDispatchOnUI(const IPC::Message& message,
                                    IPC::Sender* sender);
 
   // Call this if a message couldn't be deserialized.  This kills the renderer.
   // Can be called on any thread.
   virtual void BadMessageReceived();
 
-  const std::vector<uint32>& message_classes_to_filter() const {
-    return message_classes_to_filter_;
-  }
-
  protected:
   virtual ~BrowserMessageFilter();
 
  private:
   friend class base::RefCountedThreadSafe<BrowserMessageFilter,
                                           BrowserMessageFilterTraits>;
 
   class Internal;
   friend class BrowserChildProcessHostImpl;
   friend class BrowserPpapiHost;
   friend class RenderProcessHostImpl;
 
   // This is private because the only classes that need access to it are made
   // friends above. This is only guaranteed to be valid on creation, after that
   // this class could outlive the filter.
   IPC::ChannelProxy::MessageFilter* GetFilter();
 
   // This implements IPC::ChannelProxy::MessageFilter so that we can hide that
   // from child classes. Internal keeps a reference to this class, which is why
   // there's a weak pointer back. This class could outlive Internal based on
   // what the child class does in its OnDestruct method.
   Internal* internal_;
 
   IPC::Channel* channel_;
   base::ProcessId peer_pid_;
 
-  std::vector<uint32> message_classes_to_filter_;
-
 #if defined(OS_WIN)
   base::Lock peer_handle_lock_;
   base::ProcessHandle peer_handle_;
 #endif
 };
 
 struct BrowserMessageFilterTraits {
   static void Destruct(const BrowserMessageFilter* filter) {
     filter->OnDestruct();
   }
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_MESSAGE_FILTER_H_