Restart Chrome if per session flags have been specified on ChromeOS.

chromeos/dbus/session_manager_client.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 "chromeos/dbus/session_manager_client.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 253 matching lines @@
       const std::string& account_name,
       const std::string& policy_blob,
       const StorePolicyCallback& callback) OVERRIDE {
     CallStorePolicyByUsername(
         login_manager::kSessionManagerStoreDeviceLocalAccountPolicy,
         account_name,
         policy_blob,
         callback);
   }
 
+  virtual void SetFlagsForUser(const std::string& username,
+                               const std::vector<std::string>& flags) OVERRIDE {
+    CallSetFlagsByUsername(login_manager::kSessionManagerSetFlagsForUser,

[Mattias Nissler (ping if slow), 2013/06/12 14:53:03]

You can just inline CallSetFlagsByUsername, the function above calls the helper
just for code sharing.

[pastarmovj, 2013/06/12 16:19:33]

Done.

+                           username,
+                           flags);
+  }
+
  private:
   // Makes a method call to the session manager with no arguments and no
   // response.
   void SimpleMethodCallToSessionManager(const std::string& method_name) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
@@ skipping 31 matching lines @@
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &SessionManagerClientImpl::OnStorePolicy,
             weak_ptr_factory_.GetWeakPtr(),
             method_name,
             callback));
   }
 
+  void CallSetFlagsByUsername(const std::string& method_name,
+                              const std::string& username,
+                              const std::vector<std::string>& flags) {
+    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
+                                 method_name);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(username);
+    writer.AppendArrayOfStrings(flags);
+    session_manager_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
+  }
+
   // Called when kSessionManagerRestartJob method is complete.
   void OnRestartJob(dbus::Response* response) {
     LOG_IF(ERROR, !response)
         << "Failed to call "
         << login_manager::kSessionManagerRestartJob;
   }
 
   // Called when kSessionManagerStartSession method is complete.
   void OnStartSession(dbus::Response* response) {
     LOG_IF(ERROR, !response)
@@ skipping 255 matching lines @@
         base::Bind(callback, true),
         false);
   }
   virtual void StoreDeviceLocalAccountPolicy(
       const std::string& account_name,
       const std::string& policy_blob,
       const StorePolicyCallback& callback) OVERRIDE {
     user_policies_[account_name] = policy_blob;
     callback.Run(true);
   }
+  virtual void SetFlagsForUser(const std::string& username,
+                               const std::vector<std::string>& flags) OVERRIDE {
+  }
 
   static void StoreFileInBackground(const base::FilePath& path,
                                     const std::string& data) {
     const int size = static_cast<int>(data.size());
     if (!file_util::CreateDirectory(path.DirName()) ||
         file_util::WriteFile(path, data.data(), size) != size) {
       LOG(WARNING) << "Failed to write policy key to " << path.value();
     }
   }
 
@@ skipping 14 matching lines @@
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos