Add a centralized mechanism for whitelisting access to extension permissions.

chrome/browser/chromeos/web_socket_proxy.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 "chrome/browser/chromeos/web_socket_proxy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 159 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_WEB_SOCKET_PROXY_STARTED,
       content::NotificationService::AllSources(), content::Details<int>(&port));
 }
 
 class Conn;
 
 // Websocket to TCP proxy server.
 class Serv {
  public:
-  explicit Serv(const std::vector<std::string>& allowed_origins);
+  Serv();
   ~Serv();
 
   // Do not call it twice.
   void Run();
 
   // Terminates running server (should be called on a different thread).
   void Shutdown();
   // Called on network change.  Reinitializes DNS resolution service.
   void OnNetworkChange();
 
   void ZapConn(Conn*);
   void MarkConnImportance(Conn*, bool important);
   Conn* GetFreshConn();
   bool IsConnSane(Conn*);
-  bool IsOriginAllowed(const std::string& origin);
   void CloseAll();
 
   static void OnConnect(int listening_sock, short event, void*);
   static void OnControlRequest(int fd, short event, void*);
 
   struct event_base* evbase() { return evbase_; }
 
-  // Checked against value of Origin field specified
-  // in a client websocket handshake.
-  std::vector<std::string> allowed_origins_;
-
   // Libevent base.
   struct event_base* evbase_;
 
   // Socket to listen incoming websocket connections.
   int listening_sock_;
 
   // TODO(dilmah): remove this extra socket as soon as obsolete
   // getPassportForTCP function is removed from webSocketProxyPrivate API.
   // Additional socket to listen incoming connections on fixed port 10101.
   int extra_listening_sock_;
@@ skipping 579 matching lines @@
   bool is_read_pipe_blocked_;
   bool is_write_pipe_blocked_;
   base::WeakPtrFactory<SSLChan> weak_factory_;
   MessageLoopForIO::FileDescriptorWatcher read_pipe_controller_;
   MessageLoopForIO::FileDescriptorWatcher write_pipe_controller_;
 
   friend class base::DeleteHelper<SSLChan>;
   DISALLOW_COPY_AND_ASSIGN(SSLChan);
 };
 
-Serv::Serv(const std::vector<std::string>& allowed_origins)
-    : allowed_origins_(allowed_origins),
-      evbase_(NULL),
+Serv::Serv()
+    : evbase_(NULL),
       listening_sock_(-1),
       extra_listening_sock_(-1),
       shutdown_requested_(false) {
-  std::sort(allowed_origins_.begin(), allowed_origins_.end());
   control_descriptor_[0] = -1;
   control_descriptor_[1] = -1;
 }
 
 Serv::~Serv() {
   CloseAll();
 }
 
 void Serv::Run() {
   if (evbase_ || shutdown_requested_)
@@ skipping 222 matching lines @@
   Conn* cs = new Conn(this);
   conn_pool_.push_front(cs);
   rev_map_[cs] = conn_pool_.begin();
   return cs;
 }
 
 bool Serv::IsConnSane(Conn* cs) {
   return rev_map_.find(cs) != rev_map_.end();
 }
 
-bool Serv::IsOriginAllowed(const std::string& origin) {
-  return allowed_origins_.empty() || std::binary_search(
-      allowed_origins_.begin(), allowed_origins_.end(), origin);
-}
-
 // static
 void Serv::OnConnect(int listening_sock, short event, void* ctx) {
   Serv* self = static_cast<Serv*>(ctx);
   Conn* cs = self->GetFreshConn();
   int sock = accept(listening_sock, NULL, NULL);
   if (sock < 0 || !SetNonBlock(sock)) {
     // Read readiness was triggered on listening socket
     // yet we failed to accept a connection; definitely weird.
     NOTREACHED();
     self->ZapConn(cs);
@@ skipping 188 matching lines @@
     return STATUS_ABORT;
   }
   if (header_fields_["sec-websocket-version"] != "8" &&
       header_fields_["sec-websocket-version"] != "13") {
     return STATUS_ABORT;
   }
   // Normalize origin (e.g. leading slash).
   GURL origin = GURL(GetOrigin()).GetOrigin();
   if (!origin.is_valid())
     return STATUS_ABORT;
-  if (!master_->IsOriginAllowed(origin.spec()))
-    return STATUS_ABORT;
 
   if (!requested_parameters_.empty()) {
     destname_ = requested_parameters_["hostname"];
     int port;
     if (!base::StringToInt(requested_parameters_["port"], &port) ||
         port < 0 || port >= 1 << 16) {
       return STATUS_ABORT;
     }
     destport_ = port;
     destaddr_ = requested_parameters_["addr"];
@@ skipping 611 matching lines @@
 
 // static
 Conn::EventKey Conn::last_evkey_ = 0;
 
 // static
 base::LazyInstance<Conn::EventKeyMap>::Leaky
     Conn::evkey_map_ = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-WebSocketProxy::WebSocketProxy(const std::vector<std::string>& allowed_origins)
-    : impl_(new Serv(allowed_origins)) {
+WebSocketProxy::WebSocketProxy() : impl_(new Serv()) {
 }
 
 WebSocketProxy::~WebSocketProxy() {
   delete static_cast<Serv*>(impl_);
   impl_ = NULL;
 }
 
 void WebSocketProxy::Run() {
   static_cast<Serv*>(impl_)->Run();
 }
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos