Linux sandbox: cleanup sandbox-bpf naming.

sandbox/linux/seccomp-bpf/codegen.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 <stdio.h>
 
 #include "sandbox/linux/seccomp-bpf/codegen.h"
 
 namespace {
 
 // Helper function for Traverse().
-void TraverseRecursively(std::set<playground2::Instruction*>* visited,
-                         playground2::Instruction* instruction) {
+void TraverseRecursively(std::set<sandbox::Instruction*>* visited,
+                         sandbox::Instruction* instruction) {
   if (visited->find(instruction) == visited->end()) {
     visited->insert(instruction);
     switch (BPF_CLASS(instruction->code)) {
       case BPF_JMP:
         if (BPF_OP(instruction->code) != BPF_JA) {
           TraverseRecursively(visited, instruction->jf_ptr);
         }
         TraverseRecursively(visited, instruction->jt_ptr);
         break;
       case BPF_RET:
         break;
       default:
         TraverseRecursively(visited, instruction->next);
         break;
     }
   }
 }
 
 }  // namespace
 
-namespace playground2 {
+namespace sandbox {
 
 CodeGen::CodeGen() : compiled_(false) {}
 
 CodeGen::~CodeGen() {
   for (Instructions::iterator iter = instructions_.begin();
        iter != instructions_.end();
        ++iter) {
     delete *iter;
   }
   for (BasicBlocks::iterator iter = basic_blocks_.begin();
        iter != basic_blocks_.end();
        ++iter) {
     delete *iter;
   }
 }
 
-void CodeGen::PrintProgram(const Sandbox::Program& program) {
-  for (Sandbox::Program::const_iterator iter = program.begin();
+void CodeGen::PrintProgram(const SandboxBPF::Program& program) {
+  for (SandboxBPF::Program::const_iterator iter = program.begin();
        iter != program.end();
        ++iter) {
     int ip = (int)(iter - program.begin());
     fprintf(stderr, "%3d) ", ip);
     switch (BPF_CLASS(iter->code)) {
       case BPF_LD:
         if (iter->code == BPF_LD + BPF_W + BPF_ABS) {
           fprintf(stderr, "LOAD %d  // ", (int)iter->k);
           if (iter->k == offsetof(struct arch_seccomp_data, nr)) {
             fprintf(stderr, "System call number\n");
@@ skipping 636 matching lines @@
     }
 
     // Proceed to next basic block.
     offset += bb->instructions.size();
     bb->offset = offset;
   }
   return;
 }
 
 void CodeGen::ConcatenateBasicBlocks(const BasicBlocks& basic_blocks,
-                                     Sandbox::Program* program) {
+                                     SandboxBPF::Program* program) {
   // Our basic blocks have been sorted and relative jump offsets have been
   // computed. The last remaining step is for all the instructions in our
   // basic blocks to be concatenated into a BPF program.
   program->clear();
   for (BasicBlocks::const_iterator bb_iter = basic_blocks.begin();
        bb_iter != basic_blocks.end();
        ++bb_iter) {
     const BasicBlock& bb = **bb_iter;
     for (Instructions::const_iterator insn_iter = bb.instructions.begin();
          insn_iter != bb.instructions.end();
          ++insn_iter) {
       const Instruction& insn = **insn_iter;
       program->push_back(
           (struct sock_filter) {insn.code, insn.jt, insn.jf, insn.k});
     }
   }
   return;
 }
 
-void CodeGen::Compile(Instruction* instructions, Sandbox::Program* program) {
+void CodeGen::Compile(Instruction* instructions, SandboxBPF::Program* program) {
   if (compiled_) {
     SANDBOX_DIE(
         "Cannot call Compile() multiple times. Create a new code "
         "generator instead");
   }
   compiled_ = true;
 
   BranchTargets branch_targets;
   FindBranchTargets(*instructions, &branch_targets);
   TargetsToBlocks all_blocks;
   BasicBlock* first_block =
       CutGraphIntoBasicBlocks(instructions, branch_targets, &all_blocks);
   MergeTails(&all_blocks);
   BasicBlocks basic_blocks;
   TopoSortBasicBlocks(first_block, all_blocks, &basic_blocks);
   ComputeRelativeJumps(&basic_blocks, all_blocks);
   ConcatenateBasicBlocks(basic_blocks, program);
   return;
 }
 
 }  // namespace

[Robert Sesek, 2013/12/10 21:52:05]

"namespace sandbox"

[jln (very slow on Chromium), 2013/12/10 22:01:48]

Done.