Support minimal use case for gcdPrivate.sendMessage('/privet/v3/setup/start') on linux.

chrome/browser/extensions/api/gcd_private/gcd_private_api.cc

 // Copyright 2014 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/extensions/api/gcd_private/gcd_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 24 matching lines @@
 namespace gcd_private = api::gcd_private;
 
 namespace {
 
 const int kNumRequestsNeeded = 2;
 
 const char kIDPrefixCloudPrinter[] = "cloudprint:";
 const char kIDPrefixGcd[] = "gcd:";
 const char kIDPrefixMdns[] = "mdns:";
 
-#if defined(ENABLE_WIFI_BOOTSTRAPPING)
 const char kPrivatAPISetup[] = "/privet/v3/setup/start";
 const char kPrivetKeyWifi[] = "wifi";
 const char kPrivetKeyPassphrase[] = "passphrase";
 const char kPrivetKeySSID[] = "ssid";
 const char kPrivetKeyPassphraseDotted[] = "wifi.passphrase";
-#endif  // ENABLE_WIFI_BOOTSTRAPPING
 
 scoped_ptr<Event> MakeDeviceStateChangedEvent(
     const gcd_private::GCDDevice& device) {
   scoped_ptr<base::ListValue> params =
       gcd_private::OnDeviceStateChanged::Create(device);
   scoped_ptr<Event> event(
       new Event(gcd_private::OnDeviceStateChanged::kEventName, params.Pass()));
   return event.Pass();
 }
 
@@ skipping 119 matching lines @@
   scoped_ptr<local_discovery::PrivetDeviceLister> privet_device_lister_;
   GCDDeviceMap known_devices_;
 
   GCDSessionMap sessions_;
   int last_session_id_;
 
   content::BrowserContext* const browser_context_;
 
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
   scoped_ptr<local_discovery::wifi::WifiManager> wifi_manager_;
+#endif
   PasswordMap wifi_passwords_;
-#endif
 };
 
 class GcdPrivateRequest : public local_discovery::PrivetV3Session::Request {
  public:
   GcdPrivateRequest(const std::string& api,
                     const base::DictionaryValue& input,
                     const GcdPrivateAPIImpl::MessageResponseCallback& callback,
                     GcdPrivateSessionHolder* session_holder);
   virtual ~GcdPrivateRequest();
 
@@ skipping 181 matching lines @@
   }
 
   found->second->ConfirmCode(code, callback);
 }
 
 void GcdPrivateAPIImpl::SendMessage(int session_id,
                                     const std::string& api,
                                     const base::DictionaryValue& input,
                                     MessageResponseCallback callback) {
   const base::DictionaryValue* input_actual = &input;
-#if defined(ENABLE_WIFI_BOOTSTRAPPING)
   scoped_ptr<base::DictionaryValue> input_cloned;
 
   if (api == kPrivatAPISetup) {
     const base::DictionaryValue* wifi = NULL;
 
     if (input.GetDictionary(kPrivetKeyWifi, &wifi)) {
       std::string ssid;
 
       if (!wifi->GetString(kPrivetKeySSID, &ssid)) {
         callback.Run(gcd_private::STATUS_SETUPPARSEERROR,
@@ skipping 11 matching lines @@
                        base::DictionaryValue());
           return;
         }
 
         input_cloned.reset(input.DeepCopy());
         input_cloned->SetString(kPrivetKeyPassphraseDotted, found->second);
         input_actual = input_cloned.get();
       }
     }
   }
-#endif
 
   GCDSessionMap::iterator found = sessions_.find(session_id);
 
   if (found == sessions_.end()) {
     callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR,
                  base::DictionaryValue());
     return;
   }
 
   found->second->SendMessage(api, *input_actual, callback);
@@ skipping 498 matching lines @@
 }
 
 GcdPrivateGetCommandsListFunction::~GcdPrivateGetCommandsListFunction() {
 }
 
 bool GcdPrivateGetCommandsListFunction::RunAsync() {
   return false;
 }
 
 }  // namespace extensions