src/cloud_print/gcp20/prototype/printer_state.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cloud_print/gcp20/prototype/printer_state.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/json/json_reader.h"
   9 #include "base/json/json_writer.h"
  10 #include "base/logging.h"
  11 #include "base/safe_numerics.h"
  12 #include "base/values.h"
  13
  14 namespace {
  15
  16 const char kRegistered[] = "registered";
  17 const char kUser[] = "user";
  18 const char kDeviceId[] = "device_id";
  19 const char kRefreshToken[] = "refresh_token";
  20 const char kXmppJid[] = "xmpp_jid";
  21 const char kAccessToken[] = "access_token";
  22 const char kAccessTokenUpdate[] = "access_token_update";
  23
  24 const char kLocalSettings[] = "local_settings";
  25 const char kLocalSettingsLocalDiscovery[] = "local_discovery";
  26 const char kLocalSettingsAccessTokenEnabled[] = "access_token_enabled";
  27 const char kLocalSettingsLocalPrintingEnabled[] =
  28     "printer/local_printing_enabled";
  29 const char kLocalSettingsXmppTimeoutValue[] = "xmpp_timeout_value";
  30
  31 }  // namespace
  32
  33 PrinterState::PrinterState()
  34     : registration_state(UNREGISTERED),
  35       confirmation_state(CONFIRMATION_PENDING) {
  36 }
  37
  38 PrinterState::~PrinterState() {
  39 }
  40
  41 namespace printer_state {
  42
  43 bool SaveToFile(const base::FilePath& path, const PrinterState& state) {
  44   base::DictionaryValue json;
  45   if (state.registration_state == PrinterState::REGISTERED) {
  46     json.SetBoolean(kRegistered, true);
  47     json.SetString(kUser, state.user);
  48     json.SetString(kDeviceId, state.device_id);
  49     json.SetString(kRefreshToken, state.refresh_token);
  50     json.SetString(kXmppJid, state.xmpp_jid);
  51     json.SetString(kAccessToken, state.access_token);
  52     json.SetInteger(kAccessTokenUpdate,
  53                     static_cast<int>(state.access_token_update.ToTimeT()));
  54
  55     scoped_ptr<base::DictionaryValue> local_settings(new base::DictionaryValue);
  56     local_settings->SetBoolean(kLocalSettingsLocalDiscovery,
  57                                state.local_settings.local_discovery);
  58     local_settings->SetBoolean(kLocalSettingsAccessTokenEnabled,
  59                                state.local_settings.access_token_enabled);
  60     local_settings->SetBoolean(kLocalSettingsLocalPrintingEnabled,
  61                                state.local_settings.local_printing_enabled);
  62     local_settings->SetInteger(kLocalSettingsXmppTimeoutValue,
  63                                state.local_settings.xmpp_timeout_value);
  64     json.Set(kLocalSettings, local_settings.release());
  65   } else {
  66     json.SetBoolean(kRegistered, false);
  67   }
  68
  69   std::string json_str;
  70   base::JSONWriter::WriteWithOptions(&json,
  71                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
  72                                      &json_str);
  73   int size = base::checked_numeric_cast<int>(json_str.size());
  74   return (file_util::WriteFile(path, json_str.data(), size) == size);
  75 }
  76
  77 bool LoadFromFile(const base::FilePath& path, PrinterState* state) {
  78   std::string json_str;
  79   if (!base::ReadFileToString(path, &json_str)) {
  80     LOG(ERROR) << "Cannot open file.";
  81     return false;
  82   }
  83
  84   scoped_ptr<base::Value> json_val(base::JSONReader::Read(json_str));
  85   base::DictionaryValue* json = NULL;
  86   if (!json_val || !json_val->GetAsDictionary(&json)) {
  87     LOG(ERROR) << "Cannot read JSON dictionary from file.";
  88     return false;
  89   }
  90
  91   bool registered = false;
  92   if (!json->GetBoolean(kRegistered, &registered)) {
  93     LOG(ERROR) << "Cannot parse |registered| state.";
  94     return false;
  95   }
  96
  97   if (!registered)
  98     return true;
  99
 100   std::string user;
 101   if (!json->GetString(kUser, &user)) {
 102     LOG(ERROR) << "Cannot parse |user|.";
 103     return false;
 104   }
 105
 106   std::string device_id;
 107   if (!json->GetString(kDeviceId, &device_id)) {
 108     LOG(ERROR) << "Cannot parse |device_id|.";
 109     return false;
 110   }
 111
 112   std::string refresh_token;
 113   if (!json->GetString(kRefreshToken, &refresh_token)) {
 114     LOG(ERROR) << "Cannot parse |refresh_token|.";
 115     return false;
 116   }
 117
 118   std::string xmpp_jid;
 119   if (!json->GetString(kXmppJid, &xmpp_jid)) {
 120     LOG(ERROR) << "Cannot parse |xmpp_jid|.";
 121     return false;
 122   }
 123
 124   std::string access_token;
 125   if (!json->GetString(kAccessToken, &access_token)) {
 126     LOG(ERROR) << "Cannot parse |access_token|.";
 127     return false;
 128   }
 129
 130   int access_token_update;
 131   if (!json->GetInteger(kAccessTokenUpdate, &access_token_update)) {
 132     LOG(ERROR) << "Cannot parse |access_token_update|.";
 133     return false;
 134   }
 135
 136   LocalSettings local_settings;
 137   base::DictionaryValue* settings_dict;
 138   if (!json->GetDictionary(kLocalSettings, &settings_dict)) {
 139     LOG(WARNING) << "Cannot read |local_settings|. Reset to default.";
 140   } else {
 141     if (!settings_dict->GetBoolean(kLocalSettingsLocalDiscovery,
 142                                    &local_settings.local_discovery) ||
 143         !settings_dict->GetBoolean(kLocalSettingsAccessTokenEnabled,
 144                                    &local_settings.access_token_enabled) ||
 145         !settings_dict->GetBoolean(kLocalSettingsLocalPrintingEnabled,
 146                                    &local_settings.local_printing_enabled) ||
 147         !settings_dict->GetInteger(kLocalSettingsXmppTimeoutValue,
 148                                    &local_settings.xmpp_timeout_value)) {
 149       LOG(WARNING) << "Cannot parse |local_settings|. Reset to default.";
 150       local_settings = LocalSettings();
 151     }
 152   }
 153
 154   *state = PrinterState();
 155   state->registration_state = PrinterState::REGISTERED;
 156   state->user = user;
 157   state->device_id = device_id;
 158   state->refresh_token = refresh_token;
 159   state->xmpp_jid = xmpp_jid;
 160   state->access_token = access_token;
 161   state->access_token_update = base::Time::FromTimeT(access_token_update);
 162   state->local_settings = local_settings;
 163   return true;
 164 }
 165
 166 }  // namespace printer_state
 167