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

content/public/browser/browser_message_filter.cc

 // 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.
 
 #include "content/public/browser/browser_message_filter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 58 matching lines @@
       return true;
     }
 
     BrowserThread::PostTask(
         thread, FROM_HERE,
         base::Bind(
             base::IgnoreResult(&Internal::DispatchMessage), this, message));
     return true;
   }
 
-  virtual bool GetSupportedMessageClasses(
-      std::vector<uint32>* supported_message_classes) const OVERRIDE {
-    supported_message_classes->assign(
-        filter_->message_classes_to_filter().begin(),
-        filter_->message_classes_to_filter().end());
-    return true;
-  }
-
   // Dispatches a message to the derived class.
   bool DispatchMessage(const IPC::Message& message) {
     bool message_was_ok = true;
     bool rv = filter_->OnMessageReceived(message, &message_was_ok);
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO) || rv) <<
         "Must handle messages that were dispatched to another thread!";
     if (!message_was_ok) {
       content::RecordAction(
           base::UserMetricsAction("BadMessageTerminate_BMF"));
       filter_->BadMessageReceived();
     }
 
     return rv;
   }
 
   scoped_refptr<BrowserMessageFilter> filter_;
 
   DISALLOW_COPY_AND_ASSIGN(Internal);
 };
 
-BrowserMessageFilter::BrowserMessageFilter(uint32 message_class_to_filter)
-    : internal_(NULL),
-      channel_(NULL),
+BrowserMessageFilter::BrowserMessageFilter()
+    : internal_(NULL), channel_(NULL),
 #if defined(OS_WIN)
       peer_handle_(base::kNullProcessHandle),
 #endif
-      peer_pid_(base::kNullProcessId),
-      message_classes_to_filter_(1, message_class_to_filter) {}
-
-BrowserMessageFilter::BrowserMessageFilter(
-    const uint32* message_classes_to_filter,
-    size_t num_message_classes_to_filter)
-    : internal_(NULL),
-      channel_(NULL),
-#if defined(OS_WIN)
-      peer_handle_(base::kNullProcessHandle),
-#endif
-      peer_pid_(base::kNullProcessId),
-      message_classes_to_filter_(
-          message_classes_to_filter,
-          message_classes_to_filter + num_message_classes_to_filter) {
-  DCHECK(num_message_classes_to_filter);
+      peer_pid_(base::kNullProcessId) {
 }
 
 base::ProcessHandle BrowserMessageFilter::PeerHandle() {
 #if defined(OS_WIN)
   base::AutoLock lock(peer_handle_lock_);
   if (peer_handle_ == base::kNullProcessHandle)
     base::OpenPrivilegedProcessHandle(peer_pid_, &peer_handle_);
 
   return peer_handle_;
 #else
@@ skipping 82 matching lines @@
 
 IPC::ChannelProxy::MessageFilter* BrowserMessageFilter::GetFilter() {
   // We create this on demand so that if a filter is used in a unit test but
   // never attached to a channel, we don't leak Internal and this;
   DCHECK(!internal_) << "Should only be called once.";
   internal_ = new Internal(this);
   return internal_;
 }
 
 }  // namespace content