Cleanup

native_client_sdk/src/libraries/nacl_mounts/mount_http.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 "nacl_mounts/mount_http.h"
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <ppapi/c/pp_errors.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <vector>
 #include "nacl_mounts/mount_node_dir.h"
 #include "nacl_mounts/osinttypes.h"
 #include "utils/auto_lock.h"
 
 #if defined(WIN32)
 #define snprintf _snprintf
 #endif
 
-static const int USR_ID = 1001;
-static const int GRP_ID = 1002;
-
 
 typedef std::vector<char *> StringList_t;
 static size_t SplitString(char *str, const char *delim, StringList_t* list) {
   char *item = strtok(str, delim);
 
   list->clear();
   while (item) {
     list->push_back(item);
     item = strtok(NULL, delim);
   }
@@ skipping 118 matching lines @@
  public:
   virtual int FSync();
   virtual int GetDents(size_t offs, struct dirent* pdir, size_t count);
   virtual int GetStat(struct stat* stat);
   virtual int Read(size_t offs, void* buf, size_t count);
   virtual int Truncate(size_t size);
   virtual int Write(size_t offs, const void* buf, size_t count);
   virtual size_t GetSize();
 
  protected:
-  MountNodeHttp(Mount* mount, int ino, int dev, const std::string& url);
-  virtual int Close();
+  MountNodeHttp(Mount* mount, const std::string& url);
 
  private:
   bool OpenUrl(const char* method,
                StringMap_t* request_headers,
                PP_Resource* out_loader,
                PP_Resource* out_request,
                PP_Resource* out_response,
                int32_t* out_statuscode,
                StringMap_t* out_response_headers);
 
@@ skipping 178 matching lines @@
   errno = ENOSYS;
   return -1;
 }
 
 size_t MountNodeHttp::GetSize() {
   // TODO(binji): This value should be cached properly; i.e. obey the caching
   // headers returned by the server.
   return stat_.st_size;
 }
 
-MountNodeHttp::MountNodeHttp(Mount* mount, int ino, int dev,
-                           const std::string& url)
-    : MountNode(mount, ino, dev),
+MountNodeHttp::MountNodeHttp(Mount* mount, const std::string& url)
+    : MountNode(mount),
       url_(url) {
 }
 
-
-int MountNodeHttp::Close() {
-  return 0;
-}
-
 bool MountNodeHttp::OpenUrl(const char* method,
                            StringMap_t* request_headers,
                            PP_Resource* out_loader,
                            PP_Resource* out_request,
                            PP_Resource* out_response,
                            int32_t* out_statuscode,
                            StringMap_t* out_response_headers) {
   // Assume lock_ is already held.
 
   PepperInterface* ppapi = mount_->ppapi();
@@ skipping 77 matching lines @@
   NodeMap_t::iterator iter = node_cache_.find(path.Join());
   if (iter != node_cache_.end()) {
     return iter->second;
   }
 
   // If we can't find the node in the cache, create it
   std::string url = url_root_ + (path.IsAbsolute() ?
       path.Range(1, path.Size()) :
       path.Join());
 
-  MountNodeHttp* node = new MountNodeHttp(this, num_nodes_++, dev_, url);
-  if (!node->Init(mode, USR_ID, GRP_ID) || (0 != node->GetStat(NULL))) {
+  MountNodeHttp* node = new MountNodeHttp(this, url);
+  if (!node->Init(mode) || (0 != node->GetStat(NULL))) {
     node->Release();
     return NULL;
   }
 
   MountNodeDir* parent = FindOrCreateDir(path.Parent());
   node_cache_[path.Join()] = node;
   parent->AddChild(path.Basename(), node);
   return node;
 }
 
@@ skipping 107 matching lines @@
 }
 
 MountNodeDir* MountHttp::FindOrCreateDir(const Path& path) {
   std::string strpath = path.Join();
   NodeMap_t::iterator iter = node_cache_.find(strpath);
   if (iter != node_cache_.end()) {
     return static_cast<MountNodeDir*>(iter->second);
   }
 
   // If the node does not exist, create it, and add it to the node cache
-  MountNodeDir* node = new MountNodeDir(this, num_nodes_, dev_);
-  node->Init(S_IREAD, USR_ID, GRP_ID);
+  MountNodeDir* node = new MountNodeDir(this);
+  node->Init(S_IREAD);
   node_cache_[strpath] = node;
 
   // If not the root node, find the parent node and add it to the parent
   if (!path.Top()) {
     MountNodeDir* parent = FindOrCreateDir(path.Parent());
     parent->AddChild(path.Basename(), node);
   }
 
   return node;
 }
@@ skipping 40 matching lines @@
         default:
           fprintf(stderr, "Unable to parse write %s for %s.\n", modestr, name);
           return false;
       }
 
       Path path(name);
       std::string url = url_root_ + (path.IsAbsolute() ?
           path.Range(1, path.Size()) :
           path.Join());
 
-      MountNode* node = new MountNodeHttp(this, num_nodes_, dev_, url);
-      node->Init(mode, USR_ID, GRP_ID);
+      MountNode* node = new MountNodeHttp(this, url);
+      node->Init(mode);
       node->stat_.st_size = atoi(lenstr);
 
       MountNodeDir* dir_node = FindOrCreateDir(path.Parent());
       dir_node->AddChild(path.Basename(), node);
 
       std::string pname = path.Join();
       node_cache_[pname] = node;
     }
   }
 
   return true;
 }
 
 char *MountHttp::LoadManifest(const std::string& manifestName) {
   Path manifestPath(manifestName);
   MountNode* manifiestNode = Open(manifestPath, O_RDONLY);
 
   if (manifiestNode) {
     char *text = new char[manifiestNode->GetSize() + 1];
     off_t len = manifiestNode->Read(0, text, manifiestNode->GetSize());
     manifiestNode->Release();
 
     text[len] = 0;
     return text;
   }
 
   fprintf(stderr, "Could not open manifest: %s\n", manifestName.c_str());
   return NULL;
 }