Unify var tracking between webkit and the proxy.

ppapi/proxy/ppb_font_proxy.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 "ppapi/proxy/ppb_font_proxy.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/resource_object_base.h"
+#include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_image_data_api.h"
 #include "ppapi/thunk/thunk.h"
 
+using ppapi::StringVar;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::WebKitForwarding;
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 bool PPTextRunToTextRun(const PP_TextRun_Dev* run,
                         WebKitForwarding::Font::TextRun* output) {
-  const std::string* str = PluginVarTracker::GetInstance()->GetExistingString(
-      run->text);
+  scoped_refptr<StringVar> str(StringVar::FromPPVar(run->text));
   if (!str)
     return false;
 
-  output->text = *str;
+  output->text = str->value();
   output->rtl = PP_ToBool(run->rtl);
   output->override_direction = PP_ToBool(run->override_direction);
   return true;
 }
 
 InterfaceProxy* CreateFontProxy(Dispatcher* dispatcher,
                                 const void* target_interface) {
   return new PPB_Font_Proxy(dispatcher, target_interface);
 }
 
@@ skipping 28 matching lines @@
   if (!dispatcher)
     return PP_MakeUndefined();
 
   // Assume the font families don't change, so we can cache the result globally.
   static std::string families;
   if (families.empty()) {
     dispatcher->SendToBrowser(
         new PpapiHostMsg_PPBFont_GetFontFamilies(&families));
   }
 
-  PP_Var result;
-  result.type = PP_VARTYPE_STRING;
-  result.value.as_id = PluginVarTracker::GetInstance()->MakeString(families);
-  return result;
+  return StringVar::StringToPPVar(0, families);
 }
 
 bool PPB_Font_Proxy::OnMessageReceived(const IPC::Message& msg) {
   // There aren't any font messages.
   NOTREACHED();
   return false;
 }
 
 Font::Font(const HostResource& resource,
            const PP_FontDescription_Dev& desc)
     : PluginResource(resource),
       webkit_event_(false, false) {
   TRACE_EVENT0("ppapi proxy", "Font::Font");
-  const std::string* face = PluginVarTracker::GetInstance()->GetExistingString(
-      desc.face);
+  scoped_refptr<StringVar> face(StringVar::FromPPVar(desc.face));
 
   WebKitForwarding* forwarding = GetDispatcher()->GetWebKitForwarding();
 
   WebKitForwarding::Font* result = NULL;
   RunOnWebKitThread(base::Bind(&WebKitForwarding::CreateFontForwarding,
                                base::Unretained(forwarding),
                                &webkit_event_, desc,
-                               face ? *face : std::string(),
+                               face.get() ? face->value() : std::string(),
                                GetDispatcher()->preferences(),
                                &result));
   font_forwarding_.reset(result);
 }
 
 Font::~Font() {
 }
 
 ppapi::thunk::PPB_Font_API* Font::AsPPB_Font_API() {
   return this;
 }
 
 Font* Font::AsFont() {
   return this;
 }
 
 PP_Bool Font::Describe(PP_FontDescription_Dev* description,
                        PP_FontMetrics_Dev* metrics) {
   TRACE_EVENT0("ppapi proxy", "Font::Describe");
   std::string face;
   PP_Bool result = PP_FALSE;
   RunOnWebKitThread(base::Bind(&WebKitForwarding::Font::Describe,
                                base::Unretained(font_forwarding_.get()),
                                &webkit_event_, description, &face, metrics,
                                &result));
 
-  if (result == PP_TRUE) {
-    description->face.type = PP_VARTYPE_STRING;
-    description->face.value.as_id =
-        PluginVarTracker::GetInstance()->MakeString(face);
-  } else {
-    description->face.type = PP_VARTYPE_UNDEFINED;
-  }
+  if (PP_ToBool(result))
+    description->face = StringVar::StringToPPVar(0, face);
+  else
+    description->face = PP_MakeUndefined();
   return result;
 }
 
 PP_Bool Font::DrawTextAt(PP_Resource pp_image_data,
                          const PP_TextRun_Dev* text,
                          const PP_Point* position,
                          uint32_t color,
                          const PP_Rect* clip,
                          PP_Bool image_data_is_opaque) {
   TRACE_EVENT0("ppapi proxy", "Font::DrawTextAt");
@@ skipping 69 matching lines @@
   return result;
 }
 
 void Font::RunOnWebKitThread(const base::Closure& task) {
   GetDispatcher()->PostToWebKitThread(FROM_HERE, task);
   webkit_event_.Wait();
 }
 
 }  // namespace proxy
 }  // namespace pp