Generate and connect a Pepper identifier for Chrome OS

content/browser/renderer_host/pepper_message_filter.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 "content/browser/renderer_host/pepper_message_filter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/pepper_lookup_request.h"
 #include "content/browser/renderer_host/pepper_tcp_server_socket.h"
 #include "content/browser/renderer_host/pepper_tcp_socket.h"
 #include "content/browser/renderer_host/pepper_udp_socket.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/pepper_messages.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/font_list_async.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/content_client.h"
 #include "net/base/address_family.h"
 #include "net/base/address_list.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/host_port_pair.h"
@@ skipping 12 matching lines @@
 
 using content::BrowserThread;
 using content::RenderViewHostImpl;
 using ppapi::NetAddressPrivateImpl;
 
 namespace {
 
 const size_t kMaxSocketsAllowed = 1024;
 const uint32 kInvalidSocketID = 0;
 
+// The ID is a 256-bit hash digest hex-encoded.
+const int kDRMIdentifierSize = (256 / 8) * 2;
+// The path to the file containing the DRM ID.
+// It is mirrored from
+//   chrome/browser/chromeos/system/drm_settings.cc

[jam, 2012/06/01 22:21:06]

this is a layering violation. this code, in content, is basically reaching out
to chrome profile code through the file system. it needs to go through the
Content API instead.

[jam, 2012/06/01 22:32:40]

and just to be clear, there should be a getter, most likely on BrowserContext,
that gets the unique id. I thought I saw a change that had that before.

+const char kDRMIdentifierFile[] = "Pepper DRM ID.0";
+
 }  // namespace
 
 PepperMessageFilter::PepperMessageFilter(
     ProcessType type,
     int process_id,
-    content::ResourceContext* resource_context)
+    content::BrowserContext* browser_context)
     : process_type_(type),
       process_id_(process_id),
-      resource_context_(resource_context),
+      resource_context_(browser_context ?
+          browser_context->GetResourceContext() : NULL),
       host_resolver_(NULL),
       next_socket_id_(1) {
   DCHECK(type == RENDERER);
+  DCHECK(browser_context);
+  browser_path_ = browser_context->GetPath();
   DCHECK(resource_context_);
 }
 
 PepperMessageFilter::PepperMessageFilter(ProcessType type,
                                          net::HostResolver* host_resolver)
     : process_type_(type),
       process_id_(0),
       resource_context_(NULL),
       host_resolver_(host_resolver),
       next_socket_id_(1) {
   DCHECK(type == PLUGIN);
   DCHECK(host_resolver);
 }
 
 void PepperMessageFilter::OverrideThreadForMessage(
     const IPC::Message& message,
     BrowserThread::ID* thread) {
   if (message.type() == PpapiHostMsg_PPBTCPSocket_Connect::ID ||
       message.type() == PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress::ID ||
       message.type() == PpapiHostMsg_PPBUDPSocket_Bind::ID ||
       message.type() == PpapiHostMsg_PPBTCPServerSocket_Listen::ID ||
       message.type() == PpapiHostMsg_PPBHostResolver_Resolve::ID) {
     *thread = BrowserThread::UI;
-  } else if (message.type() == PpapiHostMsg_PPBFlash_GetDeviceID::ID) {
+  } else if (message.type() == PepperMsg_GetDeviceID::ID) {
     *thread = BrowserThread::FILE;
   }
 }
 
 bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
                                             bool* message_was_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(PepperMessageFilter, msg, *message_was_ok)
     IPC_MESSAGE_HANDLER(PepperMsg_GetLocalTimeZoneOffset,
                         OnGetLocalTimeZoneOffset)
@@ skipping 34 matching lines @@
                         OnNetworkMonitorStart)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBNetworkMonitor_Stop,
                         OnNetworkMonitorStop)
 
     // X509 certificate messages.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBX509Certificate_ParseDER,
                         OnX509CertificateParseDER);
 
     // Flash messages.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_UpdateActivity, OnUpdateActivity)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_GetDeviceID, OnGetDeviceID)
+    IPC_MESSAGE_HANDLER(PepperMsg_GetDeviceID, OnGetDeviceID)
 
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 void PepperMessageFilter::OnIPAddressChanged() {
   GetAndSendNetworkList();
 }
 
@@ skipping 467 matching lines @@
   // than the screensaver timeout, it won't go on.
   int value = 0;
   if (SystemParametersInfo(SPI_GETSCREENSAVETIMEOUT, 0, &value, 0))
     SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT, value, NULL, 0);
 #else
   // TODO(brettw) implement this for other platforms.
 #endif
 }
 
 void PepperMessageFilter::OnGetDeviceID(std::string* id) {
-  // TODO(brettw) implement this.
-  *id = "<undefined>";
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  id->clear();
+
+  // Grab the contents of the DRM identifier file.
+  FilePath drm_id_file = browser_path_;
+  drm_id_file = drm_id_file.AppendASCII(kDRMIdentifierFile);
+
+  // This method should not be called with high frequency and its
+  // useful to be able to validate use with a VLOG.
+  VLOG(1) << "DRM ID requested @ " << drm_id_file.value();
+
+  if (browser_path_.empty()) {
+    LOG(ERROR) << "GetDeviceID requested from outside the RENDERER context.";
+    return;
+  }
+
+  // TODO(wad,brettw) Add OffTheRecord() enforcement here.
+  // Normally this is left for the plugin to do, but in the
+  // future we should check here as an added safeguard.
+
+  char id_buf[kDRMIdentifierSize];
+  if (file_util::ReadFile(drm_id_file, id_buf, kDRMIdentifierSize) !=
+      kDRMIdentifierSize) {
+    VLOG(1) << "file not readable: " << drm_id_file.value();
+    return;
+  }
+  id->assign(id_buf, kDRMIdentifierSize);
 }
 
 void PepperMessageFilter::GetFontFamiliesComplete(
     IPC::Message* reply_msg,
     scoped_ptr<base::ListValue> result) {
   std::string output;
   for (size_t i = 0; i < result->GetSize(); i++) {
     base::ListValue* cur_font;
     if (!result->GetList(i, &cur_font))
       continue;
@@ skipping 109 matching lines @@
     network_copy.state = PP_NETWORKLIST_UP;
     network_copy.display_name = network.name;
     network_copy.mtu = 0;
   }
   for (NetworkMonitorIdSet::iterator it = network_monitor_ids_.begin();
        it != network_monitor_ids_.end(); ++it) {
     Send(new PpapiMsg_PPBNetworkMonitor_NetworkList(
         ppapi::API_ID_PPB_NETWORKMANAGER_PRIVATE, *it, *list_copy));
   }
 }