Remove RemoteAccessClientFirewallTraversal policy and code paths.

remoting/client/plugin/chromoting_instance.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 "remoting/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
-#include "base/values.h"
 #include "media/base/media.h"
-#include "ppapi/c/dev/ppb_query_policy_dev.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/rect.h"
 // TODO(wez): Remove this when crbug.com/86353 is complete.
 #include "ppapi/cpp/private/var_private.h"
 #include "remoting/base/util.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/plugin/chromoting_scriptable_object.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_view.h"
 #include "remoting/client/plugin/pepper_view_proxy.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/proto/auth.pb.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
 
 namespace remoting {
 
-namespace {
-
-const char kClientFirewallTraversalPolicyName[] =
-    "remote_access.client_firewall_traversal";
-
-}  // namespace
-
-PPP_PolicyUpdate_Dev ChromotingInstance::kPolicyUpdatedInterface = {
-  &ChromotingInstance::PolicyUpdatedThunk,
-};
-
 // This flag blocks LOGs to the UI if we're already in the middle of logging
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 static bool g_logging_to_plugin = false;
 static bool g_has_logging_instance = false;
 static base::Lock g_logging_lock;
 static ChromotingInstance* g_logging_instance = NULL;
 static logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 const char* ChromotingInstance::kMimeType = "pepper-application/x-chromoting";
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::InstancePrivate(pp_instance),
       initialized_(false),
       plugin_message_loop_(
           new PluginMessageLoopProxy(&plugin_thread_delegate_)),
       context_(plugin_message_loop_),
       scale_to_fit_(false),
-      enable_client_nat_traversal_(false),
-      initial_policy_received_(false),
       thread_proxy_(new ScopedThreadProxy(plugin_message_loop_)) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 }
 
 ChromotingInstance::~ChromotingInstance() {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
@@ skipping 39 matching lines @@
   // Check to make sure the media library is initialized.
   // http://crbug.com/91521.
   if (!media::IsMediaLibraryInitialized()) {
     LOG(ERROR) << "Media library not initialized.";
     return false;
   }
 
   // Start all the threads.
   context_.Start();
 
-  SubscribeToNatTraversalPolicy();
-
   // Create the chromoting objects that don't depend on the network connection.
   view_.reset(new PepperView(this, &context_));
   view_proxy_ = new PepperViewProxy(this, view_.get(), plugin_message_loop_);
   rectangle_decoder_ = new RectangleUpdateDecoder(
       context_.decode_message_loop(), view_proxy_);
 
   // Default to a medium grey.
   view_->SetSolidFill(0xFFCDCDCD);
 
   return true;
 }
 
 void ChromotingInstance::Connect(const ClientConfig& config) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
-  // This can only happen at initialization if the Javascript connect call
-  // occurs before the enterprise policy is read.  We are guaranteed that the
-  // enterprise policy is pushed at least once, we we delay the connect call.
-  if (!initial_policy_received_) {
-    VLOG(1) << "Delaying connect until initial policy is read.";
-    // base::Unretained() is safe here because |delayed_connect_| is
-    // used only with |thread_proxy_|.
-    delayed_connect_ = base::Bind(&ChromotingInstance::Connect,
-                                  base::Unretained(this), config);
-    return;
-  }
-
   host_connection_.reset(new protocol::ConnectionToHost(
-      context_.network_message_loop(), this, enable_client_nat_traversal_));
+      context_.network_message_loop(), this, true));
 
   input_handler_.reset(new PepperInputHandler(&context_,
                                               host_connection_.get(),
                                               view_proxy_));
 
   client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
                                      view_proxy_, rectangle_decoder_.get(),
                                      input_handler_.get(), NULL));
 
   LOG(INFO) << "Connecting to " << config.host_jid
@@ skipping 276 matching lines @@
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
   if (!input_handler_.get()) {
     return;
   }
 
   input_handler_->ReleaseAllKeys();
 }
 
-// static
-void ChromotingInstance::PolicyUpdatedThunk(PP_Instance pp_instance,
-                                            PP_Var pp_policy_json) {
-  ChromotingInstance* instance = static_cast<ChromotingInstance*>(
-      pp::Module::Get()->InstanceForPPInstance(pp_instance));
-  std::string policy_json =
-      pp::Var(pp::Var::DontManage(), pp_policy_json).AsString();
-  instance->HandlePolicyUpdate(policy_json);
-}
-
-void ChromotingInstance::SubscribeToNatTraversalPolicy() {
-  pp::Module::Get()->AddPluginInterface(PPP_POLICYUPDATE_DEV_INTERFACE,
-                                        &kPolicyUpdatedInterface);
-  const PPB_QueryPolicy_Dev* query_policy_interface =
-      static_cast<PPB_QueryPolicy_Dev const*>(
-          pp::Module::Get()->GetBrowserInterface(
-              PPB_QUERYPOLICY_DEV_INTERFACE));
-  query_policy_interface->SubscribeToPolicyUpdates(pp_instance());
-}
-
-bool ChromotingInstance::IsNatTraversalAllowed(
-    const std::string& policy_json) {
-  int error_code = base::JSONReader::JSON_NO_ERROR;
-  std::string error_message;
-  scoped_ptr<base::Value> policy(base::JSONReader::ReadAndReturnError(
-      policy_json, true, &error_code, &error_message));
-
-  if (!policy.get()) {
-    LOG(ERROR) << "Error " << error_code << " parsing policy: "
-               << error_message << ".";
-    return false;
-  }
-
-  if (!policy->IsType(base::Value::TYPE_DICTIONARY)) {
-    LOG(ERROR) << "Policy must be a dictionary";
-    return false;
-  }
-
-  base::DictionaryValue* dictionary =
-      static_cast<base::DictionaryValue*>(policy.get());
-  bool traversal_policy = false;
-  if (!dictionary->GetBoolean(kClientFirewallTraversalPolicyName,
-                              &traversal_policy)) {
-    // Disable NAT traversal on any failure of reading the policy.
-    return false;
-  }
-
-  return traversal_policy;
-}
-
-void ChromotingInstance::HandlePolicyUpdate(const std::string policy_json) {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
-  bool traversal_policy = IsNatTraversalAllowed(policy_json);
-
-  // If the policy changes from traversal allowed, to traversal denied, we
-  // need to immediately drop all connections and redo the conneciton
-  // preparation.
-  if (traversal_policy == false &&
-      traversal_policy != enable_client_nat_traversal_) {
-    if (client_.get()) {
-      // This will delete the client and network related objects.
-      Disconnect();
-    }
-  }
-
-  initial_policy_received_ = true;
-  enable_client_nat_traversal_ = traversal_policy;
-
-  if (!delayed_connect_.is_null()) {
-    thread_proxy_->PostTask(FROM_HERE, delayed_connect_);
-    delayed_connect_.Reset();
-  }
-}
-
 }  // namespace remoting